tadforce 0.2.0 → 0.4.0

package/.claude-plugin/marketplace.json

@@ -4,14 +4,14 @@
     "name": "Jihad AZAMI HASSANI"
   },
   "metadata": {
-    "description": "TADForce — technical architecture documents for Salesforce orgs, written by your agent from the org's own metadata."
+    "description": "TADForce — AI-Powered Salesforce Technical Documentation, written by your agent from the org's own metadata."
   },
   "plugins": [
     {
       "name": "tadforce",
       "source": "./",
-      "description": "Generate, review and validate the Technical Architecture Document of any Salesforce org (/tadforce, /tadforce-review).",
-      "version": "0.2.0",
+      "description": "AI-Powered Salesforce Technical Documentation: generate, review, validate and update the Technical Architecture Document of any Salesforce org (/tadforce, /tadforce-review, /tadforce-update).",
+      "version": "0.4.0",
       "author": { "name": "Jihad AZAMI HASSANI" },
       "license": "Apache-2.0",
       "category": "documentation"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "tadforce",
-  "version": "0.2.0",
-  "description": "Point it at a Salesforce org, get the Technical Architecture Document a senior architect would write: evidence-based, reproducible, reviewable in the browser. All Salesforce products and industries.",
+  "version": "0.4.0",
+  "description": "AI-Powered Salesforce Technical Documentation — the Technical Architecture Document of any Salesforce org, written from the org's own metadata: evidence-based, reproducible, reviewable in the browser, kept up to date. All Salesforce products and industries.",
   "author": {
     "name": "Jihad AZAMI HASSANI",
     "url": "https://github.com/azamiji"

package/README.md

@@ -2,7 +2,7 @@
 
 <img src="assets/banner.svg" alt="TADForce — point it at a Salesforce org, get the architecture document a senior architect would write" width="100%">
 
-### The architect's scribe for Salesforce orgs.
+### AI-Powered Salesforce Technical Documentation
 
 **Four commands. One org. One Technical Architecture Document — evidence-based, reproducible, reviewable in the browser.**
 
@@ -20,7 +20,7 @@
 [![Copilot](https://img.shields.io/badge/GitHub%20Copilot-skill-6E40C9)](#-quick-start)
 [![Read-only](https://img.shields.io/badge/org%20access-read--only-16A34A)](#-read-only-by-design)
 
-[**Live demo**](https://azamiji.github.io/TADForce/) · [Quick start](#-quick-start) · [The four commands](#-four-commands) · [Every project type](#-every-kind-of-salesforce-project) · [Français](README.fr.md)
+[**Live demo**](https://azamiji.github.io/TADForce/) · [Quick start](#-quick-start) · [The four commands](#-four-commands) · [Every project type](#-every-kind-of-salesforce-project)
 
 </div>
 
@@ -47,11 +47,9 @@ From your Salesforce DX project (or an empty folder):
 npx tadforce doctor
 ```
 
-Then, in your AI agent (Claude Code, Codex, Cursor, Copilot…):
+That one command installs everything: it downloads TADForce, installs the agent skills in your project, connects to the org, collects the metadata and asks you the few questions only a human can answer. When everything is green, it says so and **offers to hand over to your AI agent** (Claude Code, Codex, Gemini CLI or Cursor, detected on your machine), which writes, builds and validates the document — nothing else to type.
 
-```text
-/tadforce
-```
+Already in your agent? Type `/tadforce`: it runs the same checks, then writes.
 
 <table>
 <tr><th width="33%">A — Claude Code plugin</th><th width="33%">B — Any agent (Agent Skills)</th><th width="33%">C — Deterministic / CI</th></tr>
@@ -140,7 +138,7 @@ The document carries **the client's logo and colours**: the logo is searched in
 | **No org access**, sources only | `--source local` documents the package directories of the project |
 | **Unlocked or managed packages** | Namespaces and installed packages are detected and documented with their evidence |
 | **Any cloud, any industry** | Sections switch on only when the product is detected, each with its writing guide (below) |
-| **French or English** | Document, skeletons and interface in both; Salesforce terms stay in English |
+| **Any language** | English and French built in. Any other language (Spanish, German, Italian, Portuguese, Arabic, Japanese…): pick it in `doctor`, your agent translates the headings and labels once, then writes in that language. Salesforce terms stay in English |
 
 ### Products and industries
 
@@ -219,7 +217,7 @@ The TADForce CLI sends nothing anywhere: no telemetry, no server, no account. It
 
 ## 🗺️ Roadmap
 
-- [ ] More languages for the skeletons (es, de, pt, it)
+- [ ] Built-in skeletons for more languages (es, de, pt, it) — any language already works through the agent; contributions welcome
 - [ ] Your own template: add, hide or rename chapters from `tadforce/templates/`
 - [ ] More examples: Service + Experience Cloud, an ISV package
 - [ ] Salesforce CLI plugin wrapper (`sf tad …`)
@@ -232,7 +230,17 @@ Issues and pull requests are welcome — new product modules, new extractors, ne
 
 ## 👥 Community
 
-TADForce was born in the **Salesforce Architect Community Group of Casablanca**. Share your generated documents (anonymised!), your module ideas and your war stories in the issues. Star the repo if TADForce saved you a week. ⭐
+TADForce was born for the **Salesforce ecosystem**: architects, consultants, integrators and in-house teams who need documentation they can trust.
+
+Your experience is what makes it better. Tell us, in the [issues](https://github.com/azamiji/TADForce/issues) and [discussions](https://github.com/azamiji/TADForce/discussions):
+
+- **How it went** — the kind of org and project, the time it took, what worked out of the box.
+- **How good the result was** — sections that read like a senior architect wrote them, and sections that did not.
+- **What to improve** — a product it should detect better, a section that misses the point, a question it should have asked.
+
+Please share your feedback, not your documents: they describe your clients' systems.
+
+If TADForce saved you a week, **star the repo** ⭐ — it is how other Salesforce teams find it.
 
 ## 👤 Author
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tadforce",
-  "version": "0.2.0",
-  "description": "Point it at a Salesforce org. Get the technical architecture document a senior architect would write — evidence-based, reproducible, reviewable.",
+  "version": "0.4.0",
+  "description": "AI-Powered Salesforce Technical Documentation — the Technical Architecture Document of any Salesforce org, written from the org's own metadata: evidence-based, reproducible, reviewable in the browser, kept up to date.",
   "type": "module",
   "bin": {
     "tadforce": "bin/tadforce.js"

package/skills/tadforce/SKILL.md

@@ -19,7 +19,7 @@ The CLI (`npx tadforce …`) does everything deterministic: org access, retrieve
 6. **Numbers come from facts.** Write counts as `{{n:apex.classes}}`, links as `{{ref:section-id}}`. Never type a count by hand.
 7. **Client document ≠ internal review.** The TAD is factual and positive. Debt, risks and recommendations go to the Improvement Axes document.
 8. **Technical names in code font must exist** in the inventory (`tadforce validate` checks it).
-9. **Write in the document language** (`tadforce.config.json › language`). Keep Salesforce terms in English (Lead, Queue, Record Type, Named Credential…).
+9. **Write in the document language** (`tadforce.config.json › language` — any language; outside English and French, translate the headings and labels once, see `references/workflow.md › Other languages`). Keep Salesforce terms in English (Lead, Queue, Record Type, Named Credential…).
 10. **Ask in batches.** Group your questions; never ask what the facts already answer.
 
 ## The run

package/skills/tadforce/references/questions.md

@@ -4,23 +4,22 @@ Ask in **blocks**, each in one message, with your proposed answer for every item
 
 ## Block A — startup (before or right after authorization)
 
-`npx tadforce doctor --json` returns these questions with a `recommended` answer each (from the org when connected). Ask them all in one message:
+`npx tadforce doctor --json` asks, in this order and one step at a time: the **project** (is this the Salesforce project to document?), the **org** (is this the org?), then these framing questions — six, each with a `recommended` answer. Ask them all in one message and let the human accept them all at once:
 
-1. Document language — recommended: the org default language.
-2. Client name and short code (file names) — recommended: `Organization.Name` / `<CODE>`.
-3. Integrator — **optional**. Blank: the document names the client only (no empty « Integrator » line, no badge).
+1. Document language — recommended: the org default language. English and French are built in; any other language works (the headings and labels are translated once, see `workflow.md › Other languages`).
+2. Client name, as it must appear in the document — recommended: `Organization.Name`. The short code (file names) and the reference are derived from it.
+3. Integrator — **optional**. Blank: the document names the client only (no empty « Integrator » line, no badge). The Improvement Axes then carry the client's brand.
 4. Author — **optional**. Blank: no author is shown anywhere. Never put your own name or the agent's.
-5. Document title — recommended: « Salesforce CRM Platform » (or the client's name for the solution).
+5. Functional specifications — **optional**: paths to PDF / DOCX / MD files (copied into `knowledge/inputs/specs/`).
 6. Scope — **optional**: name patterns of the components the project owns (`NWB_*,Loan*`), when the org is shared with other teams. Blank: the whole org.
-7. Client logo — **optional**: a file or a URL. Blank: TADForce searches the org (static resources, content assets, site assets), then falls back to an initials badge. The document colours follow the org's Lightning theme, else the logo. If none is found and the client has a public website, you may *offer* to look for the logo there — fetch it only after the human says yes.
-8. Functional specifications — **optional**: paths to PDF / DOCX / MD files (copied into `knowledge/inputs/specs/`).
-9. Metadata — `org` (recommended: retrieve everything from the org), `local` (the sources of this project), or `both`.
 
-Answer with `npx tadforce doctor --json --confirm --lang fr --client "…" --short ABC --integrator none --author "…" --title "…" [--scope "…"] [--logo …] [--specs … | --no-specs] [--source org]`.
+Answer with `npx tadforce doctor --json --confirm --lang fr --client "…" --integrator none --author none [--specs … | --no-specs] [--scope "…"]`. The title stays « Salesforce CRM Platform » unless the human gives one (`--title`).
+
+Then come the metadata choice (`source`, which is also the go for the retrieve), the **branding** (logo and colours found in the org — never fetch a logo from the web without the human's go-ahead), and Blocks B to D.
 
 FR example:
 
-> Pour démarrer, je propose : langue **français** (langue par défaut de l'org : fr_FR) · client **« Banque Exemple »** (code `BEX`) · intégrateur : **aucun** · auteur : **aucun** · titre **« Plateforme CRM Salesforce »** · périmètre : **toute l'org** · logo : **cherché dans l'org** · spécifications fonctionnelles : **aucune** · métadonnées : **depuis l'org**. Je confirme ? Indiquez seulement ce qui change.
+> Pour démarrer, je propose : langue **français** (langue par défaut de l'org : fr_FR) · client **« Banque Exemple »** · intégrateur : **aucun** · auteur : **aucun** · spécifications fonctionnelles : **aucune** · périmètre : **toute l'org**. Je valide tout ? Indiquez seulement ce qui change.
 
 ## Block B — external systems (from `facts/questions.json › systems`)
 

package/skills/tadforce/references/workflow.md

@@ -13,11 +13,16 @@ npx tadforce doctor --json
 | `next` says | You do |
 |---|---|
 | install the missing tools | `sf-cli` missing: you may run `npm install --global @salesforce/cli` after asking. Node or a browser missing: human action (or `npx @puppeteer/browsers install chrome-headless-shell@stable` + `TADFORCE_CHROME`) |
-| the human logs in | No org, or an expired session. Ask the human to run `npx tadforce doctor` in a terminal (it opens the browser) or `sf org login web --alias <a> --set-default [--instance-url https://test.salesforce.com]`. No org at all: `--source local` documents the local sources |
-| ask the human these questions | Block A of `questions.md`: one message, a recommendation for each. Then `npx tadforce doctor --json --confirm --lang fr --client "…" --short ABC --integrator "…"\|none --author "…"\|none --title "…" [--scope "NWB_*,Loan*"] [--logo <file\|url>] [--specs a.pdf,b.docx \| --no-specs] [--source org\|local\|both]` |
-| write the answers to the knowledge files | Blocks B, C and D of `questions.md` → `knowledge/glossary.yml`, `knowledge/exclusions.yml`; then `npx tadforce facts` and `npx tadforce doctor --json --facts-reviewed` |
+| question `project` | Confirm with the human that this Salesforce project is the one to document → `--project yes`. Not in a project: `doctor` creates nothing; it proposes the projects found nearby → `--project <path>` (then always pass `--cwd <path>`), or `--project create` only if the human asks for a new project here |
+| question `org` | Show the org (alias, user, URL) and ask whether the TAD is about it → `--org <alias>`. Another org, or none connected: the human logs in (`sf org login web --alias <a> [--instance-url https://test.salesforce.com]`, it opens the browser), then ask again and pass `--org <a>`. No org at all: `--source local` |
+| framing questions | Block A of `questions.md`: one message, the recommended answer for each, « accept all » allowed → `--confirm --lang … --client "…" --integrator …|none --author …|none [--specs …|--no-specs] [--scope …]` |
+| question `source` | org (retrieve everything, read-only, several minutes), local, or self (the human retrieves first). The answer **is the go**: ask before passing `--source org` — the retrieve starts right away. `self`: wait until the human says the retrieve is done, then `--source local` |
+| question `branding` | Show the logo and colours found → `--branding keep`, or `--logo <file|url>` |
+| systems / exclusions / features | Blocks B, C and D of `questions.md`, recommended answers shown → write `knowledge/*.yml`, `npx tadforce facts`, then `--facts-reviewed` |
 | `tadforce build` | Ready: write and build |
 
+Run by a person in a terminal, a green `doctor` starts the AI agent found on the machine on `/tadforce` (`--agent claude|codex|gemini|cursor`, `--no-launch` to stop there). Run by you (`--json`, or inside an agent session), it never starts another agent: carry on with the writing.
+
 What `doctor` does by itself, read-only:
 
 - creates the SFDX project and the `tadforce/` workspace if missing, installs the skills for the agents found;
@@ -25,6 +30,16 @@ What `doctor` does by itself, read-only:
 - metadata, as chosen (`source`): **org** (recommended — the org is the truth) retrieves every useful type with a `*` manifest into `tadforce/.snapshot` (`force-app` is never touched; large orgs take several minutes: tell the human); **local** reads the package directories; **both** combines them. Then `facts/facts.json`, `facts/org.json` (aggregates), `facts/questions.json`, the chapter skeletons in `tadforce/src/`;
 - branding from evidence: the client logo searched in the snapshot (static resources, content assets, site assets named *logo*), the colours from the org's Lightning theme (`BrandingSet`), else from the logo. Never fetch a logo from the web without the human's go-ahead; when they agree, pass its URL with `--logo`.
 
+### Other languages
+
+English and French are built in. Any other language (`--lang es`, `de`, `it`, `pt`, `nl`, `ar`, `ja`…) works too: the skeletons are scaffolded in English and `tadforce/i18n/<lang>.json` is created from the English labels. Once, before writing:
+
+1. Translate the headings of every `tadforce/src/*/*.md` file into the document language. Keep the `{#anchors}`, the `{-}` markers, the `<!-- tad:… -->` lines and the `@@…@@` directives exactly as they are.
+2. Translate every value of `tadforce/i18n/<lang>.json` (cover, tables, figures, buttons of the HTML). Keep the keys and the `{placeholders}`; set `meta.htmlLang`. Delete the `_translate` line.
+3. Write the sections in that language; Salesforce terms stay in English.
+
+`doctor` shows a reminder until step 2 is done. To ship the language for everyone, contribute it (issue template « New language »).
+
 ### Optional inputs
 
 - **Functional specifications** (`--specs`): copied into `knowledge/inputs/specs/`. Read them before chapters 3 and 5; they are evidence level P2/P3 (`evidence-rules.md`). They explain the *why*; the metadata still decides the *what*.

package/src/build/render.js

@@ -107,7 +107,7 @@ export async function buildDocument(wsCtx, doc, opts = {}) {
   const problems = [];
   const facts = loadFacts(wsCtx.ws);
   if (!facts) throw new Error('facts/facts.json not found: run `tadforce facts` first.');
-  const { lang, dict } = loadI18n(cfg.language);
+  const { lang, dict } = loadI18n(cfg.language, wsCtx.ws);
   const glossary = wsCtx.glossary() || {};
   const srcDir = wsCtx.p('src', doc);
   if (!exists(srcDir)) throw new Error(`No sources in ${srcDir}: run \`tadforce scaffold --doc ${doc}\`.`);

package/src/cli.js

@@ -38,7 +38,7 @@ const COMMANDS = { ...MAIN, ...ADVANCED };
 
 function help(all) {
   const v = readJson(path.join(PKG_ROOT, 'package.json')).version;
-  console.log(`${c.violet('▲')} ${c.bold('TADForce')} ${v} — technical architecture documents for Salesforce orgs. ${c.dim('No evidence, no sentence.')}\n`);
+  console.log(`${c.violet('▲')} ${c.bold('TADForce')} ${v} — AI-Powered Salesforce Technical Documentation. ${c.dim('No evidence, no sentence.')}\n`);
   console.log(`Usage: ${c.bold('npx tadforce <command> [options]')}\n`);
   for (const [k, [, d]] of Object.entries(MAIN)) console.log(`  ${c.cyan(k.padEnd(15))} ${d}`);
   if (all) {

package/src/commands/docs.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { exists, writeJson, readText, copyDir, stableStringify } from '../util/fsx.js';
 import { loadWorkspace, sourceDirs } from '../util/config.js';
 import { TEMPLATES } from '../util/paths.js';
+import { LANGUAGES, normalizeLang, templateLang } from '../util/i18n.js';
 import { extractFacts, readCodeAnalyzer, loadFacts } from '../facts/index.js';
 import { collectOrgFacts } from '../facts/org.js';
 import { fingerprints } from '../facts/fingerprints.js';
@@ -70,7 +71,19 @@ export function buildQuestions(f, orgFacts) {
 
 export async function scaffold(args) {
   const ctx = loadWorkspace(args.cwd || process.cwd());
-  const lang = ctx.cfg.language === 'fr' ? 'fr' : 'en';
+  const lang = templateLang(ctx.cfg.language);
+  const target = normalizeLang(ctx.cfg.language);
+  // Any other language: English skeletons and labels, translated once by the agent in the workspace.
+  if (!LANGUAGES.includes(target)) {
+    const own = ctx.p('i18n', `${target}.json`);
+    if (!exists(own)) {
+      const en = JSON.parse(readText(path.join(TEMPLATES, 'i18n', 'en.json')));
+      en.meta.htmlLang = target;
+      en._translate = `Translate every value of this file into the document language (${target}); keep the keys and the {placeholders}. Then delete this line.`;
+      writeJson(own, en);
+    }
+    log.human(`document language "${target}": the skeletons are in English. Your agent translates the headings of src/*/*.md (keep the {#anchors}) and the labels of tadforce/i18n/${target}.json, once.`);
+  }
   for (const doc of docsOf(args)) {
     const src = path.join(TEMPLATES, doc, lang);
     const dst = ctx.p('src', doc);

package/src/commands/doctor.js

@@ -8,11 +8,12 @@ import YAML from 'yaml';
 import { exists, readJson, readText, writeText } from '../util/fsx.js';
 import { findWorkspace, defaultConfig, DEFAULT_BRAND, loadWorkspace, sourceDirs } from '../util/config.js';
 import { CONFIG_FILE } from '../util/paths.js';
-import { LANGUAGES } from '../util/i18n.js';
+import { LANGUAGES, normalizeLang } from '../util/i18n.js';
 import { sfVersion, sfJson, sfInteractive, soql } from '../sf/sf.js';
 import { findBrowser, closeBrowser } from '../build/browser.js';
 import { findLogoCandidates, orgThemeColors, imageColors, paletteFrom } from '../build/brand.js';
 import { log, c, setQuiet } from '../util/log.js';
+import { installedAgents, insideAgent, launchAgent } from '../util/agents.js';
 import { ensureWorkspace, installSkills } from './init.js';
 import * as org from './org.js';
 import * as docs from './docs.js';
@@ -65,19 +66,25 @@ async function proposals(alias) {
   const out = {};
   try {
     const o = ((await soql('SELECT Name, IsSandbox, LanguageLocaleKey FROM Organization', alias)).records || [])[0] || {};
-    out.client = o.Name; out.language = /^fr/i.test(o.LanguageLocaleKey || '') ? 'fr' : 'en'; out.environment = o.IsSandbox ? 'Sandbox' : 'Production';
+    out.client = o.Name; out.language = normalizeLang(String(o.LanguageLocaleKey || 'en').split('_')[0]); out.environment = o.IsSandbox ? 'Sandbox' : 'Production';
   } catch { /* proposals stay empty */ }
   return out;
 }
 
+/** Short code for file names: initials of a multi-word name (Northwind Bank → NB), else the name cut to 8. */
+export function shortCode(name) {
+  const words = name.normalize('NFD').replace(/[̀-ͯ]/g, '').split(/[^A-Za-z0-9]+/).filter(Boolean);
+  return (words.length > 1 ? words.map((w) => w[0]).join('') : words[0] || 'CLIENT').slice(0, 8).toUpperCase();
+}
+
 const listArg = (v) => (typeof v !== 'string' ? undefined : v.split(',').map((x) => x.trim()).filter(Boolean));
 
 /** Answers given as flags (the agent's way of answering) are written to the config. */
 async function applyAnswers(ctx, args) {
   const cfg = ctx.cfg;
   const set = (cond, fn) => { if (cond) fn(); };
-  set(args.lang, () => { cfg.language = LANGUAGES.includes(args.lang) ? args.lang : 'en'; });
-  set(args.client, () => { cfg.client.name = String(args.client); if (!args.short && (cfg.client.short === 'CLIENT' || !cfg.client.short)) cfg.client.short = String(args.client).replace(/[^A-Za-z0-9]/g, '').slice(0, 8).toUpperCase(); });
+  set(args.lang, () => { cfg.language = normalizeLang(args.lang); });
+  set(args.client, () => { cfg.client.name = String(args.client); if (!args.short && (cfg.client.short === 'CLIENT' || !cfg.client.short)) cfg.client.short = shortCode(String(args.client)); });
   set(args.short, () => { cfg.client.short = String(args.short); });
   set(args.integrator !== undefined, () => { cfg.integrator.name = args.integrator === true || args.integrator === '' || args.integrator === 'none' ? null : String(args.integrator); });
   set(args.author !== undefined, () => { cfg.document.author = args.author === true || args.author === '' || args.author === 'none' ? null : String(args.author); });
@@ -103,6 +110,8 @@ async function applyAnswers(ctx, args) {
   if (args.specs !== undefined) cfg.setup.specsAsked = true; // --no-specs: none provided
   if (args.confirm || args.yes) cfg.setup.confirmed = true;
   if (args.factsReviewed) cfg.setup.factsReviewed = true;
+  if (args.branding === 'keep') cfg.setup.brandingConfirmed = true;
+  if (cfg.document.reference === 'TAD-CLIENT-CRM' && cfg.client.short !== 'CLIENT') cfg.document.reference = `TAD-${cfg.client.short}-CRM`;
   ctx.save(cfg);
 }
 
@@ -159,34 +168,13 @@ async function brand(ctx) {
   return notes;
 }
 
-/** Questions only a human can answer, each with a recommended answer. */
-function framingQuestions(cfg, prop, alias, hasLocal) {
-  const q = [];
-  const ask = (id, question, recommended, extra = {}) => q.push({ id, question, recommended, ...extra });
-  if (!cfg.setup.confirmed) {
-    ask('lang', 'Document language', prop.language || cfg.language, { options: LANGUAGES });
-    ask('client', 'Client name, as it must appear in the document', prop.client || cfg.client.name);
-    ask('short', 'Client short name (file names, references)', cfg.client.short !== 'CLIENT' ? cfg.client.short : String(prop.client || cfg.client.name).replace(/[^A-Za-z0-9]/g, '').slice(0, 8).toUpperCase());
-    ask('integrator', 'Integrator, if any (blank: the document only names the client)', cfg.integrator.name || '', { optional: true });
-    ask('author', 'Author of the document (blank: no author shown)', cfg.document.author || '', { optional: true });
-    ask('title', 'Document title', cfg.document.title);
-    ask('scope', 'Part of the org to document — name patterns such as NWB_*,Loan* (blank: the whole org)', (cfg.scope.include || []).join(','), { optional: true });
-    ask('logo', `Client logo — a file or a URL${cfg.client.logo ? ` (current: ${cfg.client.logo})` : ' (blank: searched in the org, then a badge with initials)'}`, cfg.client.logo || '', { optional: true });
-  }
-  if (!cfg.setup.specsAsked && !(cfg.inputs.specs || []).length) ask('specs', 'Functional specifications or other project documents (PDF, DOCX, MD) — comma-separated paths (blank: none)', '', { optional: true });
-  if (!cfg.source.mode) {
-    ask('source', 'Metadata to document', alias ? 'org' : 'local', { options: ['org', 'local', 'both'], help: 'org: retrieve every metadata type from the org (recommended — the org is the truth); local: the force-app sources already here' + (hasLocal ? '' : ' (none found)') + '; both: org first, local sources added' });
-  }
-  return q;
-}
-
 /** Systems to name and exclusions to confirm, from facts/questions.json. */
 function factQuestions(ctx) {
   const p = ctx.p('facts', 'questions.json');
   if (!exists(p) || ctx.cfg.setup.factsReviewed) return [];
   const qs = readJson(p);
   const out = [];
-  for (const s of qs.systems || []) out.push({ id: `system:${s.key}`, kind: 'system', question: `Which system is ${s.key}? (name as the client calls it; blank: to be confirmed)`, endpoints: s.endpoints, writeTo: 'knowledge/glossary.yml › systems' });
+  for (const s of qs.systems || []) out.push({ id: `system:${s.key}`, kind: 'system', question: `Which system is ${s.key}? (name as the client calls it)`, recommended: '', endpoints: s.endpoints, writeTo: 'knowledge/glossary.yml › systems' });
   for (const g of (qs.exclusions && qs.exclusions.groups) || []) out.push({ id: `exclude:${g.reason}`, kind: 'exclusion', question: `${g.count} component(s): ${g.reason}. Exclude from the document? (all / none / list of names)`, recommended: 'none', items: g.items, writeTo: 'knowledge/exclusions.yml › exclude' });
   out.push({ id: 'features', kind: 'features', question: 'Any feature decommissioned or switched off that the document must not describe? (blank: none)', recommended: '', writeTo: 'knowledge/exclusions.yml › features' });
   return out;
@@ -203,6 +191,10 @@ function editYaml(file, key, items) {
 /** Interactive answers to the facts questions, written to the knowledge files. */
 async function askFacts(ctx, rl, questions) {
   const systems = [], exclude = [], features = [];
+  log.step('What the metadata cannot tell:');
+  questions.forEach((q, i) => console.log(`  ${i + 1}. ${q.question}`));
+  console.log(`     ${c.dim('recommended: systems « to be confirmed » in the document, nothing excluded, no decommissioned feature')}`);
+  if (yes((await rl.question('  Accept the recommended answers? [Y/n] ')).trim())) return 0;
   for (const q of questions) {
     const a = (await rl.question(`  ${q.question}${q.items ? '\n    ' + c.dim(q.items.slice(0, 12).join(', ') + (q.items.length > 12 ? ` … +${q.items.length - 12}` : '')) : ''}${q.endpoints ? '\n    ' + c.dim(q.endpoints.join(', ')) : ''}\n  > `)).trim();
     if (!a) continue;
@@ -219,140 +211,320 @@ async function askFacts(ctx, rl, questions) {
   return systems.length + exclude.length + features.length;
 }
 
+/** Framing questions (5 to 6), each with a recommended answer. Title and short code are derived. */
+function framingQuestions(cfg, prop) {
+  if (cfg.setup.confirmed) return [];
+  const q = [];
+  const ask = (id, question, recommended, extra = {}) => q.push({ id, question, recommended, ...extra });
+  ask('lang', `Document language (${LANGUAGES.join(', ')} built in, or any code: es, de, it, pt, ar…)`, prop.language || cfg.language, { options: [...LANGUAGES, 'other'] });
+  ask('client', 'Client name, as it must appear in the document', prop.client || (cfg.client.name !== 'Client' ? cfg.client.name : ''));
+  ask('integrator', 'Integrator (blank: the document only names the client)', cfg.integrator.name || '', { optional: true });
+  ask('author', 'Author of the document (blank: no author shown)', cfg.document.author || '', { optional: true });
+  ask('specs', 'Functional specifications to use, comma-separated paths (blank: none)', (cfg.inputs.specs || []).join(','), { optional: true });
+  ask('scope', 'Part of the org to document, name patterns such as NWB_* (blank: the whole org)', (cfg.scope.include || []).join(','), { optional: true });
+  return q;
+}
+
+/** Interactive batch: the list with its recommendations, then « accept all » or one by one. */
+async function askBatch(rl, title, questions) {
+  log.step(title);
+  questions.forEach((q, i) => console.log(`  ${i + 1}. ${q.question}\n     ${c.dim('recommended:')} ${q.recommended === '' || q.recommended == null ? c.dim('(blank)') : c.bold(String(q.recommended))}`));
+  const all = (await rl.question('  Accept all the recommended answers? [Y/n] ')).trim();
+  const answers = {};
+  if (/^(|y|o|yes|oui)$/i.test(all)) { for (const q of questions) answers[q.id] = q.recommended ?? ''; return answers; }
+  for (const q of questions) {
+    const a = (await rl.question(`  ${q.question}${q.options ? ` (${q.options.join('/')})` : ''}${q.recommended ? ` [${q.recommended}]` : ''}: `)).trim();
+    answers[q.id] = a || q.recommended || '';
+    if (q.id === 'lang' && /^(other|autre)$/i.test(a)) answers.lang = (await rl.question('  Language code (es, de, it, pt, nl, ar, ja…): ')).trim() || 'en';
+  }
+  return answers;
+}
+
+const yes = (a, def = true) => (a === '' ? def : /^(y|o|yes|oui)$/i.test(a));
+
+/** Salesforce DX projects in this folder's sub-folders and next to it (two levels), for the user to pick from. */
+function findProjects(start) {
+  const out = new Set();
+  const visit = (dir, depth) => {
+    let entries = [];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    if (entries.some((e) => e.isFile() && e.name === 'sfdx-project.json')) out.add(dir);
+    if (depth <= 0) return;
+    for (const e of entries) if (e.isDirectory() && !/^(node_modules|\.|force-app$)/.test(e.name)) visit(path.join(dir, e.name), depth - 1);
+  };
+  visit(start, 2);
+  visit(path.dirname(start), 1);
+  out.delete(start);
+  return [...out].slice(0, 9);
+}
+
+const hasLocalSources = (project) => (readJson(path.join(project, 'sfdx-project.json')).packageDirectories || [])
+  .some((d) => exists(path.join(project, d.path)) && fs.readdirSync(path.join(project, d.path), { recursive: true }).some((f) => String(f).endsWith('-meta.xml')));
+
+/**
+ * Step 2 — which Salesforce project. Never creates anything without a yes. Returns the project folder,
+ * or { stop } with the question to hand back.
+ */
+async function resolveProject(start, args, rl) {
+  const ws = findWorkspace(start);
+  const confirmed = ws && defaultConfig(readJson(path.join(ws, CONFIG_FILE))).setup.projectConfirmed;
+  if (exists(path.join(start, 'sfdx-project.json'))) {
+    if (confirmed || args.project === 'yes' || args.yes) return start;
+    const name = readJson(path.join(start, 'sfdx-project.json')).name || path.basename(start);
+    if (!rl) return { stop: { id: 'project', question: `Generate the TAD for the Salesforce project "${name}" (${start})?`, recommended: 'yes', options: ['yes', '<path of another project>'] } };
+    if (yes((await rl.question(`  Salesforce project found: ${c.bold(name)} (${start}).\n  Generate the TAD for this project? [Y/n] `)).trim())) return start;
+    const other = (await rl.question('  Path of the project to document (blank: stop): ')).trim();
+    return other ? resolveProject(path.resolve(other), { ...args, project: 'yes' }, rl) : { stop: null };
+  }
+  if (args.project === 'create') return start;
+  if (args.project && args.project !== 'yes') return resolveProject(path.resolve(String(args.project)), { ...args, project: 'yes' }, rl);
+  const found = findProjects(start);
+  if (!rl) return { stop: { id: 'project', question: `No Salesforce DX project in ${start}. Which project should the TAD document? A path, or "create" to create a new project here.`, recommended: found[0] || '', options: [...found, 'create'] } };
+  console.log(`  ${c.yellow('⚠')} ${start} is not a Salesforce DX project (no sfdx-project.json).`);
+  found.forEach((p, i) => console.log(`    ${i + 1}. ${p}`));
+  console.log(`    ${c.dim('or a path · c = create a new project here · Enter = stop')}`);
+  const a = (await rl.question(`  Project to document${found.length ? ' [1]' : ''}: `)).trim();
+  if (!a && found.length) return found[0];
+  if (/^\d+$/.test(a) && found[Number(a) - 1]) return found[Number(a) - 1];
+  if (/^c$/i.test(a)) return start;
+  if (a) return resolveProject(path.resolve(a), { ...args, project: 'yes' }, rl);
+  console.log('  Open your Salesforce project folder (cd <path>), then run tadforce doctor again.');
+  return { stop: null };
+}
+
+/**
+ * Step 3 — which org. The default org is proposed, never taken silently; « no » opens the Salesforce
+ * login and asks again once an org is connected. Returns { ok } or { stop } with the question to hand back.
+ */
+async function confirmOrg(project, ctx, args, rl) {
+  const cfg = ctx.cfg;
+  if (cfg.source.mode === 'local') return { ok: true };
+  const explicit = typeof args.org === 'string' ? args.org : null;
+  let alias = explicit || (cfg.setup.orgConfirmed ? cfg.org.alias : await resolveAlias(project, {}, { org: {} }));
+  let status = alias ? await orgStatus(alias) : { ok: false, reason: 'none' };
+  const keep = () => { cfg.org.alias = alias; cfg.setup.orgConfirmed = true; ctx.save(cfg); return { ok: true }; };
+  if (status.ok && (explicit || cfg.setup.orgConfirmed)) return keep();
+  const describe = () => `${c.bold(alias)} (${status.username}, ${status.instanceUrl})`;
+  if (!rl) {
+    return { stop: alias && status.ok
+      ? { id: 'org', question: `Generate the TAD from the org "${alias}" (${status.username}, ${status.instanceUrl})?`, recommended: alias, options: [alias, 'another org: the human runs `sf org login web --alias <a>` (opens the browser), then --org <a>', 'local: document the local sources only (--source local)'] }
+      : { id: 'org', question: alias ? `The org "${alias}" is not connected (session expired). The human logs in again: \`sf org login web --alias ${alias}\`, then --org ${alias}.` : 'No org connected. The human logs in: `sf org login web --alias <a>` (opens the browser), then --org <a>; or --source local.', recommended: alias || null, human: true } };
+  }
+  for (let attempt = 0; attempt < 4; attempt++) {
+    if (alias && status.ok) {
+      const a = (await rl.question(`  ${attempt ? 'Connected' : 'Default org'}: ${describe()}\n  Generate the TAD from this org? [Y/n/l = local sources only] `)).trim();
+      if (yes(a)) return keep();
+      if (/^l/i.test(a)) { cfg.source.mode = 'local'; ctx.save(cfg); return { ok: true }; }
+    } else if (alias) console.log(`  ${c.yellow('⚠')} The org "${alias}" is not connected (session expired): log in again.`);
+    // « no », or no usable org: open the Salesforce CLI login and wait for it.
+    const def = alias && !status.ok ? alias : 'tad-org';
+    const next = (await rl.question(`  Alias for the org to connect [${def}]: `)).trim() || def;
+    const sandbox = yes((await rl.question('  Is it a sandbox? [y/N] ')).trim(), false);
+    log.human('a browser window opens: log in to the org, then click « Allow ». Waiting for the login…');
+    if (!sfInteractive(['org', 'login', 'web', '--alias', next, ...(sandbox ? ['--instance-url', 'https://test.salesforce.com'] : [])])) { log.warn('Login did not complete.'); continue; }
+    alias = next; status = await orgStatus(alias);
+  }
+  return { stop: null };
+}
+
+/** Step 5 — which metadata, and the go before a long retrieve. Returns { mode } or { stop }. */
+async function chooseSource(project, ctx, args, rl) {
+  const cfg = ctx.cfg;
+  const local = hasLocalSources(project);
+  // local sources need no go: there is no long retrieve
+  if (cfg.source.mode === 'local' || (cfg.source.mode && cfg.setup.sourceGo)) return { mode: cfg.source.mode };
+  if (typeof args.source === 'string') { cfg.source.mode = args.source === 'self' ? 'local' : args.source; cfg.setup.sourceGo = args.source !== 'self'; ctx.save(cfg); if (args.source !== 'self') return { mode: cfg.source.mode }; }
+  const org = cfg.source.mode !== 'local' && cfg.org.alias;
+  const options = [
+    ...(org ? [{ id: 'org', text: `retrieve all the metadata of ${cfg.org.alias}, read-only (several minutes)` }] : []),
+    ...(local ? [{ id: 'local', text: 'use only the metadata already in this project (force-app…)' }] : []),
+    { id: 'self', text: 'you retrieve the metadata yourself first, then give the go' },
+  ];
+  const recommended = org ? 'org' : local ? 'local' : 'self';
+  if (!rl) return { stop: { id: 'source', question: 'Which metadata should the TAD be written from? (--source answers it and is the go: the retrieve starts right away)', recommended, options: options.map((o) => `${o.id}: ${o.text}`) } };
+  log.step('Metadata for the document:');
+  options.forEach((o, i) => console.log(`    ${i + 1}. ${o.text}${o.id === recommended ? c.dim('  (recommended)') : ''}`));
+  const a = (await rl.question(`  Your choice [${options.findIndex((o) => o.id === recommended) + 1}]: `)).trim();
+  const pick = options[Number(a) - 1] || options.find((o) => o.id === recommended);
+  if (pick.id === 'self') {
+    console.log(`  Retrieve the metadata into this project, for example:\n    ${c.cyan('sf project retrieve start --manifest manifest/package.xml')}`);
+    const done = (await rl.question('  Press Enter when your retrieve is done (s = stop for now): ')).trim();
+    if (/^s/i.test(done)) return { stop: null };
+    cfg.source.mode = 'local'; cfg.setup.sourceGo = true; ctx.save(cfg);
+    return { mode: 'local' };
+  }
+  if (pick.id === 'org' && !yes((await rl.question('  The retrieve takes several minutes, read-only. Start now? [Y/n] ')).trim())) {
+    console.log('  Run tadforce doctor again when you are ready: your answers are kept.');
+    return { stop: null };
+  }
+  cfg.source.mode = pick.id; cfg.setup.sourceGo = true; ctx.save(cfg);
+  return { mode: pick.id };
+}
+
+/** Step 6a — logo and colours found from evidence, confirmed in one question. */
+async function confirmBranding(ctx, args, rl, say) {
+  for (const n of await brand(ctx)) say(() => log.ok(n));
+  const cfg = loadWorkspace(ctx.project).cfg;
+  if (cfg.setup.brandingConfirmed) return null;
+  const logo = cfg.client.logo || 'none (a badge with the initials)';
+  const colours = cfg.brand.source ? `${cfg.brand.gradient[0]} (from the ${cfg.brand.source})` : 'TADForce default colours';
+  if (!rl) return { id: 'branding', question: `Branding: logo ${logo}; colours ${colours}. Keep it? (--branding keep, or --logo <file|url>)`, recommended: 'keep' };
+  const a = (await rl.question(`  Logo: ${c.bold(logo)} · colours: ${c.bold(colours)}\n  Keep it? [Y / path or URL of another logo] `)).trim();
+  const c2 = loadWorkspace(ctx.project);
+  if (a && !yes(a, false) && !/^n/i.test(a)) {
+    try { c2.cfg.client.logo = await importAsset(c2, a, 'client-logo'); c2.save(c2.cfg); for (const n of await brand(loadWorkspace(ctx.project))) say(() => log.ok(n)); } catch (e) { log.warn(e.message); }
+  }
+  const c3 = loadWorkspace(ctx.project); c3.cfg.setup.brandingConfirmed = true; c3.save(c3.cfg);
+  return null;
+}
+
 /** One pass: where the workspace stands, and what remains. */
 async function evaluate(project, args) {
   const tools = await checks(project);
   const ws = findWorkspace(project);
   const cfg = ws ? defaultConfig(readJson(path.join(ws, CONFIG_FILE))) : defaultConfig();
-  const alias = tools.find((t) => t.id === 'sf-cli').ok ? await resolveAlias(project, args, cfg) : null;
-  const status = alias ? await orgStatus(alias) : { ok: false, reason: 'none' };
   const list = [...tools];
   const add = (id, ok, message, fix = null, human = false, level = ok ? 'ok' : 'error') => list.push({ id, ok, level, message, fix, human });
-  add('workspace', !!ws, ws ? `Workspace: ${path.relative(project, ws) || '.'}` : 'No TADForce workspace yet', ws ? null : 'created by doctor', false, ws ? 'ok' : 'warn');
-  const wantOrg = cfg.source.mode !== 'local';
-  if (wantOrg) {
-    if (status.ok) add('org', true, `Org: ${alias} (${status.instanceUrl})`);
-    else if (status.reason === 'none') add('org', false, 'No org connected to this project', 'log in once in the browser (doctor opens it), or `--source local` to document the local sources only', true);
-    else add('org', false, `Org "${alias}" is not connected (${status.detail || 'session expired'})`, 'log in again in the browser (doctor opens it)', true);
+  if (ws) add('workspace', true, `Workspace: ${path.relative(project, ws) || '.'}`);
+  if (cfg.source.mode !== 'local' && cfg.setup.orgConfirmed && cfg.org.alias) {
+    const status = await orgStatus(cfg.org.alias);
+    add('org', status.ok, status.ok ? `Org: ${cfg.org.alias} (${status.instanceUrl})` : `Org "${cfg.org.alias}" is not connected`, status.ok ? null : 'log in again (doctor opens the browser)', !status.ok);
   }
-  let facts = false, snapshot = false;
+  let facts = false;
   if (ws) {
     const ctx = loadWorkspace(project);
-    snapshot = exists(ctx.p(ctx.cfg.source.dir));
     facts = exists(ctx.p('facts', 'facts.json'));
-    add('metadata', facts, facts ? `Metadata: ${snapshot ? 'retrieved from the org' : 'local sources'} → facts/facts.json` : 'Metadata not collected yet', facts ? null : 'doctor retrieves it once the questions are answered');
+    const lang = normalizeLang(ctx.cfg.language);
+    const own = ctx.p('i18n', `${lang}.json`);
+    if (!LANGUAGES.includes(lang) && exists(own) && readJson(own)._translate) add('language', true, `Document language "${lang}": headings and labels still to translate (once)`, `the agent translates the headings of src/*/*.md (keep the {#anchors}) and the values of tadforce/i18n/${lang}.json, then removes its "_translate" line`, false, 'warn');
+    if (facts) add('metadata', true, `Metadata: ${exists(ctx.p(ctx.cfg.source.dir)) && ctx.cfg.source.mode !== 'local' ? 'retrieved from the org' : 'local sources'} → facts/facts.json`);
   }
-  return { tools, ws, cfg, alias, status, list, facts, snapshot };
+  return { tools, ws, cfg, list, facts };
 }
 
 export async function run(args) {
-  const project = path.resolve(args.cwd || process.cwd());
+  const start = path.resolve(args.cwd || process.cwd());
   const interactive = process.stdin.isTTY && !args.json && !args.yes;
   const rl = interactive ? readline.createInterface({ input: process.stdin, output: process.stdout }) : null;
   const say = (fn) => { if (!args.json) fn(); };
   if (args.json) setQuiet(true);
   say(() => log.banner('doctor'));
   try {
-    for (let round = 1; round <= 8; round++) {
-      let st = await evaluate(project, args);
-      // 1. Tools: TADForce installs what it may, the rest is a human action.
-      const sfMissing = st.tools.find((t) => t.id === 'sf-cli' && !t.ok);
-      if (sfMissing && rl && /^(y|o|yes|oui|)$/i.test((await rl.question(`  Salesforce CLI missing. Install it now with npm? [Y/n] `)).trim())) {
-        spawnSync('npm', ['install', '--global', '@salesforce/cli'], { stdio: 'inherit', shell: process.platform === 'win32' });
-        continue;
-      }
-      const blocking = st.tools.filter((t) => t.level === 'error');
-      if (blocking.length) return finish(args, st, [], [], 'install the missing tools, then run tadforce doctor again');
-
-      // 2. Workspace (with the skills for the agents of this project)
-      if (!st.ws) {
-        await quietly(args.json, () => { ensureWorkspace(project, defaultConfig({ org: { alias: st.alias || null } })); installSkills(project, null); });
-        say(() => log.ok('Workspace created: tadforce/ (skills installed for your agents)'));
-        st = await evaluate(project, args);
-      }
-      const ctx = loadWorkspace(project);
-      ctx.cfg.setup = ctx.cfg.setup || {};
-      const hasLocal = (readJson(path.join(project, 'sfdx-project.json')).packageDirectories || []).some((d) => exists(path.join(project, d.path)) && fs.readdirSync(path.join(project, d.path), { recursive: true }).some((f) => String(f).endsWith('-meta.xml')));
-      await applyAnswers(ctx, args);
-
-      // 3. Org connection: reuse the project's target-org, log in only when needed.
-      if (ctx.cfg.source.mode !== 'local' && !st.status.ok) {
-        if (!rl) return finish(args, st, [], [], 'the human logs in: run `tadforce doctor` in a terminal (it opens the browser), or `sf org login web --alias <alias> --set-default`');
-        if (hasLocal && /^l/i.test((await rl.question('  No org connected. Log in now, or document the local sources only? [Login/local] ')).trim())) { ctx.cfg.source.mode = 'local'; ctx.save(ctx.cfg); continue; }
-        const def = st.alias || 'tadforce-org';
-        const alias = (await rl.question(`  Org alias to log in [${def}]: `)).trim() || def;
-        const sandbox = /^(y|o|yes|oui)$/i.test((await rl.question('  Is it a sandbox? [y/N] ')).trim());
-        log.human('a browser window opens: log in to the org, then click « Allow ».');
-        if (sfInteractive(['org', 'login', 'web', '--alias', alias, '--set-default', ...(sandbox ? ['--instance-url', 'https://test.salesforce.com'] : [])])) { ctx.cfg.org.alias = alias; ctx.save(ctx.cfg); }
-        continue;
-      }
-      if (st.alias && ctx.cfg.org.alias !== st.alias && st.status.ok) { ctx.cfg.org.alias = st.alias; ctx.save(ctx.cfg); }
-
-      // 4. Framing questions (one batch, each with a recommendation)
-      const prop = st.status.ok ? await proposals(st.alias) : {};
-      const framing = framingQuestions(ctx.cfg, prop, st.status.ok ? st.alias : null, hasLocal);
-      if (framing.length) {
-        if (!rl) return finish(args, st, framing, [], 'ask the human these questions in one message, then run `tadforce doctor --json --confirm --<id> "<answer>"…`');
-        log.step('A few facts only you can confirm (Enter keeps the recommendation):');
-        const answers = {};
-        for (const q of framing) {
-          const a = (await rl.question(`  ${q.question}${q.options ? ` (${q.options.join('/')})` : ''}${q.recommended ? ` [${q.recommended}]` : ''}: `)).trim();
-          answers[q.id] = a || q.recommended || (q.optional ? '' : undefined);
-        }
-        const flags = { confirm: true, specs: answers.specs || false };
-        for (const [k, v] of Object.entries(answers)) if (v !== undefined) flags[k === 'logo' ? 'logo' : k] = v === '' && ['integrator', 'author'].includes(k) ? 'none' : v === '' ? undefined : v;
-        await applyAnswers(loadWorkspace(project), flags);
-        continue;
-      }
+    // 1. Tools: TADForce installs what it may, the rest is a human action.
+    let st = await evaluate(start, args);
+    if (st.tools.find((t) => t.id === 'sf-cli' && !t.ok) && rl && yes((await rl.question('  Salesforce CLI missing. Install it now with npm? [Y/n] ')).trim())) {
+      spawnSync('npm', ['install', '--global', '@salesforce/cli'], { stdio: 'inherit', shell: process.platform === 'win32' });
+      st = await evaluate(start, args);
+    }
+    if (st.tools.some((t) => t.level === 'error' && t.id !== 'sfdx-project')) return finish(args, st, [], 'install the missing tools, then run tadforce doctor again');
 
-      // 5. Metadata: retrieve from the org (curated `*` manifest) and/or read the local sources, then facts.
-      const mode = ctx.cfg.source.mode || 'org';
-      if (!st.facts || args.refresh) {
-        const a = { ...args, cwd: project, org: mode === 'local' ? false : ctx.cfg.org.alias, quiet: args.json };
-        if (mode !== 'local') {
-          say(() => log.step('Retrieving the metadata from the org (read-only, into tadforce/.snapshot)…'));
-          for (const fn of [org.manifest, org.retrieve]) { const code = await quietly(args.json, () => fn(a)); if (code) return finish(args, st, [], [], 'retrieve failed: see the messages above'); }
-        }
-        await quietly(args.json, () => docs.facts(a));
-        await quietly(args.json, () => docs.scaffold(a));
-        args.refresh = false;
-        continue;
-      }
+    // 2. The Salesforce project the TAD is about (confirmed, never created without a yes).
+    const p = await resolveProject(start, args, rl);
+    if (typeof p !== 'string') return p.stop ? finish(args, st, [p.stop], 'ask the human, then run `tadforce doctor --json --project <yes|path|create>`') : 1;
+    const project = p;
+    if (project !== start) say(() => log.ok(`Project: ${project}`));
+    if (!findWorkspace(project)) {
+      await quietly(args.json, () => { ensureWorkspace(project, defaultConfig()); installSkills(project, null); });
+      say(() => log.ok('Workspace created: tadforce/ (skills installed for your agents)'));
+    }
+    let ctx = loadWorkspace(project);
+    ctx.cfg.setup.projectConfirmed = true; ctx.save(ctx.cfg);
+    await applyAnswers(ctx, args);
+    ctx = loadWorkspace(project);
+
+    // 3. The org: the default one is proposed; « no » opens the login and asks again.
+    const o = await confirmOrg(project, ctx, args, rl);
+    if (!o.ok) return o.stop ? finish(args, await evaluate(project, args), [o.stop], 'ask the human, then run `tadforce doctor --json --org <alias>` (or --source local)') : 1;
+    ctx = loadWorkspace(project);
 
-      // 6. Branding from evidence
-      for (const n of await brand(loadWorkspace(project))) say(() => log.ok(n));
-
-      // 7. Facts questions (systems, exclusions, decommissioned features)
-      const fq = factQuestions(loadWorkspace(project));
-      if (fq.length) {
-        if (!rl) return finish(args, st, [], fq, 'ask the human, write the answers to the knowledge files, then run `tadforce doctor --json --facts-reviewed`');
-        log.step('What the metadata cannot tell (Enter: skip / to be confirmed):');
-        const changed = await askFacts(loadWorkspace(project), rl, fq);
-        const c2 = loadWorkspace(project); c2.cfg.setup.factsReviewed = true; c2.save(c2.cfg);
-        if (changed) await quietly(args.json, () => docs.facts({ cwd: project, org: c2.cfg.source.mode === 'local' ? false : c2.cfg.org.alias }));
-        continue;
+    // 4. Framing: 6 questions, each with a recommended answer; « accept all » in one keystroke.
+    const prop = ctx.cfg.org.alias && ctx.cfg.source.mode !== 'local' ? await proposals(ctx.cfg.org.alias) : {};
+    const framing = framingQuestions(ctx.cfg, prop);
+    if (framing.length) {
+      if (!rl) return finish(args, await evaluate(project, args), framing, 'ask the human in one message (recommended answers shown; « accept all » is fine), then run `tadforce doctor --json --confirm --lang … --client "…" --integrator …|none --author …|none [--specs …|--no-specs] [--scope …]`');
+      const a = await askBatch(rl, 'A few facts only you can confirm:', framing);
+      await applyAnswers(loadWorkspace(project), {
+        confirm: true, lang: a.lang, client: a.client || undefined,
+        integrator: a.integrator || 'none', author: a.author || 'none',
+        specs: a.specs || false, scope: a.scope || undefined,
+      });
+      ctx = loadWorkspace(project);
+    }
+
+    // 5. Metadata: org, local or retrieved by the user — and a go before a long retrieve.
+    if (!exists(ctx.p('facts', 'facts.json')) || args.refresh) {
+      const s = await chooseSource(project, ctx, args, rl);
+      if (!s.mode) return s.stop ? finish(args, await evaluate(project, args), [s.stop], 'ask the human; the answer is the go: `tadforce doctor --json --source org|local|self`') : 1;
+      const a = { ...args, cwd: project, org: s.mode === 'local' ? false : ctx.cfg.org.alias, quiet: args.json };
+      if (s.mode !== 'local') {
+        say(() => log.step('Retrieving the metadata from the org (read-only, into tadforce/.snapshot)…'));
+        for (const fn of [org.manifest, org.retrieve]) { const code = await quietly(args.json, () => fn(a)); if (code) return finish(args, await evaluate(project, args), [], 'the retrieve failed: see the messages above'); }
       }
+      await quietly(args.json, () => docs.facts(a));
+      await quietly(args.json, () => docs.scaffold(a));
+      ctx = loadWorkspace(project);
+    }
 
-      st = await evaluate(project, args);
-      return finish(args, st, [], [], null);
+    // 6. Branding (logo, colours) and what the metadata cannot tell — recommended answers again.
+    const b = await confirmBranding(ctx, args, rl, say);
+    if (b) return finish(args, await evaluate(project, args), [b], 'ask the human, then run `tadforce doctor --json --branding keep` (or --logo <file|url>)');
+    const fq = factQuestions(loadWorkspace(project));
+    if (fq.length) {
+      if (!rl) return finish(args, await evaluate(project, args), fq, 'ask the human in one message (recommended answers shown), write the answers to the knowledge files, then run `tadforce doctor --json --facts-reviewed`');
+      const changed = await askFacts(loadWorkspace(project), rl, fq);
+      const c2 = loadWorkspace(project); c2.cfg.setup.factsReviewed = true; c2.save(c2.cfg);
+      if (changed) await quietly(args.json, () => docs.facts({ cwd: project, org: c2.cfg.source.mode === 'local' ? false : c2.cfg.org.alias }));
     }
-    log.fail('doctor stopped after 8 rounds: run it again.');
-    return 1;
+
+    // 7. All green: say it, and offer to start the writing.
+    const code = finish(args, await evaluate(project, args), [], null);
+    // CI, agents (--json) and agent sessions stop here; a person in a terminal is offered the writing.
+    if (code || args.json || args.launch === false || !process.stdin.isTTY || insideAgent()) return code;
+    return handOver(project, args, rl);
   } finally {
     if (rl) rl.close();
   }
 }
 
+/**
+ * Everything is green: offer to start the AI agent on the writing, in this terminal. The agent is chosen
+ * once (--agent claude|codex|gemini|cursor) and remembered; --no-launch stops at the prerequisites.
+ */
+async function handOver(project, args, rl) {
+  const ctx = loadWorkspace(project);
+  const found = installedAgents();
+  const wanted = typeof args.agent === 'string' ? args.agent : ctx.cfg.setup.agent;
+  let agent = found.find((a) => a.id === wanted) || (wanted ? null : found[0]);
+  if (!agent) {
+    log.human(found.length ? `agent "${wanted}" not found; installed: ${found.map((a) => a.id).join(', ')} (--agent <id>).` : 'open your AI agent (Claude Code, Codex, Cursor, Copilot…) in this folder and type /tadforce to write the document.');
+    return 0;
+  }
+  if (rl) {
+    if (!yes((await rl.question(`  Launch the writing of the document now with ${agent.name}? [Y/n] `)).trim())) {
+      log.info(`Later: open your agent in ${project} and type /tadforce.`);
+      rl.close(); return 0;
+    }
+    if (found.length > 1 && !wanted) {
+      const pick = (await rl.question(`  Agent (${found.map((a) => a.id).join('/')}) [${agent.id}]: `)).trim();
+      agent = found.find((a) => a.id === pick) || agent;
+    }
+    rl.close();
+  }
+  ctx.cfg.setup.agent = agent.id; ctx.save(ctx.cfg);
+  log.step(`Handing over to ${agent.name}: it writes the document, then builds and validates it…`);
+  return launchAgent(agent, project);
+}
+
 async function quietly(json, fn) {
   if (!json) return fn();
   const orig = console.log; console.log = () => {};
   try { return await fn(); } finally { console.log = orig; }
 }
 
-function finish(args, st, framing, facts, next) {
+function finish(args, st, questions, next) {
   const ok = !next && st.list.every((x) => x.level !== 'error');
   if (args.json) {
-    console.log(JSON.stringify({ ok, checks: st.list, questions: [...framing, ...facts], next: next || 'tadforce build' }, null, 2));
+    console.log(JSON.stringify({ ok, checks: st.list, questions, next: next || 'tadforce build' }, null, 2));
     return ok ? 0 : 1;
   }
   for (const x of st.list) {

package/src/commands/init.js

@@ -4,7 +4,7 @@ import readline from 'node:readline/promises';
 import { exists, writeText, writeJson, copyDir, readJson } from '../util/fsx.js';
 import { defaultConfig, findWorkspace } from '../util/config.js';
 import { WORKSPACE_DIR, CONFIG_FILE, SKILLS } from '../util/paths.js';
-import { LANGUAGES } from '../util/i18n.js';
+import { LANGUAGES, normalizeLang } from '../util/i18n.js';
 import { log } from '../util/log.js';
 import { run as doctor } from './doctor.js';
 
@@ -100,7 +100,7 @@ export async function run(args) {
     const prev = existing ? readJson(path.join(ws, CONFIG_FILE)) : {};
     const base = defaultConfig(prev);
     if (interactive) log.step('A few facts only you can confirm (Enter keeps the default):');
-    const language = args.lang || (await ask(rl, `Document language (${LANGUAGES.join('/')})`, base.language));
+    const language = args.lang || (await ask(rl, `Document language (${LANGUAGES.join('/')} built in, or any code: es, de, it, pt, ar…)`, base.language));
     const clientName = args.client || (await ask(rl, 'Client name', prev.client?.name || base.client.name));
     const short = args.short || (await ask(rl, 'Client short name (used in file names)', prev.client?.short || clientName.replace(/[^A-Za-z0-9]/g, '').slice(0, 8).toUpperCase()));
     const integrator = args.integrator || (await ask(rl, 'Integrator (blank if none)', base.integrator.name || ''));
@@ -109,7 +109,7 @@ export async function run(args) {
     const alias = args.org || (await ask(rl, 'Salesforce org alias (blank: decide later)', base.org.alias || ''));
     const cfg = defaultConfig({
       ...prev,
-      language: LANGUAGES.includes(language) ? language : 'en',
+      language: normalizeLang(language),
       client: { ...base.client, name: clientName, short },
       integrator: { ...base.integrator, name: integrator || null },
       document: { ...base.document, author: author || null, title, reference: prev.document?.reference || `TAD-${short}-CRM`, environment: args.environment || base.document.environment, status: language === 'fr' && !prev.document?.status ? 'Pour revue' : base.document.status, classification: language === 'fr' && !prev.document?.classification ? 'Confidentiel' : base.document.classification },

package/src/commands/update.js

@@ -7,6 +7,7 @@ import { AREAS, fingerprints } from '../facts/fingerprints.js';
 import { loadWorkspace, sourceDirs } from '../util/config.js';
 import { TEMPLATES } from '../util/paths.js';
 import { log, c } from '../util/log.js';
+import { templateLang } from '../util/i18n.js';
 import * as org from './org.js';
 import * as docs from './docs.js';
 
@@ -121,7 +122,7 @@ export async function run(args) {
   for (const m of modulesAfter.filter((x) => !modulesBefore.includes(x))) note('modules', `new product detected: ${m}`);
   for (const m of modulesBefore.filter((x) => !modulesAfter.includes(x))) note('modules', `product no longer detected: ${m}`);
   const specs = readYaml(path.join(TEMPLATES, 'specs', 'sections.yml'), {}).sections || {};
-  const sections = affectedSections(areas, specs, sectionLocations(ctx2.cfg.language === 'fr' ? 'fr' : 'en'));
+  const sections = affectedSections(areas, specs, sectionLocations(templateLang(ctx2.cfg.language)));
 
   // 4. New version in the document control.
   const cfg = ctx2.cfg;

package/src/util/agents.js

@@ -0,0 +1,35 @@
+// AI agents TADForce can hand over to once `doctor` is green: the agent writes the document.
+import { spawnSync } from 'node:child_process';
+
+const RUN = '/tadforce';
+const PROMPT = 'Use the tadforce skill: the prerequisites are green (tadforce doctor). Write every section of the Technical Architecture Document and the Improvement Axes, then build and validate them.';
+
+/** Command-line agents, in order of preference: the argument list that starts an interactive session on the task. */
+export const AGENTS = [
+  { id: 'claude', name: 'Claude Code', bin: 'claude', args: [RUN] },
+  { id: 'codex', name: 'Codex', bin: 'codex', args: [PROMPT] },
+  { id: 'gemini', name: 'Gemini CLI', bin: 'gemini', args: ['-i', PROMPT] },
+  { id: 'cursor', name: 'Cursor Agent', bin: 'cursor-agent', args: [PROMPT] },
+];
+
+const onPath = (bin) => spawnSync(process.platform === 'win32' ? 'where' : 'which', [bin], { encoding: 'utf8' }).status === 0;
+
+/** Agents installed on this machine. */
+export function installedAgents() {
+  return AGENTS.filter((a) => onPath(a.bin));
+}
+
+/** True when TADForce already runs inside an agent session: never start another agent from there. */
+export function insideAgent() {
+  const e = process.env;
+  return !!(e.CLAUDECODE || e.CLAUDE_CODE_ENTRYPOINT || e.CODEX_SANDBOX || e.CODEX_HOME && e.CODEX_SESSION || e.GEMINI_CLI || e.CURSOR_AGENT || e.TADFORCE_NO_LAUNCH);
+}
+
+/** Start the agent in this terminal, in the project folder. Returns its exit code. */
+export function launchAgent(agent, cwd) {
+  const quote = (a) => (/^[\w./-]+$/.test(a) ? a : `"${a.replace(/"/g, '\\"')}"`);
+  const r = process.platform === 'win32'
+    ? spawnSync([agent.bin, ...agent.args].map(quote).join(' '), [], { cwd, stdio: 'inherit', shell: true })
+    : spawnSync(agent.bin, agent.args, { cwd, stdio: 'inherit' });
+  return r.status ?? 1;
+}

package/src/util/i18n.js

@@ -2,15 +2,30 @@ import path from 'node:path';
 import { readJson, exists } from './fsx.js';
 import { TEMPLATES } from './paths.js';
 
+/** Languages shipped with skeletons and interface labels. Any other language works from the English ones. */
 export const LANGUAGES = ['en', 'fr'];
 
-export function loadI18n(lang) {
-  const l = LANGUAGES.includes(lang) ? lang : 'en';
-  const base = readJson(path.join(TEMPLATES, 'i18n', 'en.json'));
-  if (l === 'en') return { lang: 'en', dict: base };
-  const p = path.join(TEMPLATES, 'i18n', `${l}.json`);
-  const loc = exists(p) ? readJson(p) : {};
-  return { lang: l, dict: merge(base, loc) };
+/** A language code as written in the config: en, fr, es, de, pt-BR… (anything else falls back to en). */
+export function normalizeLang(lang) {
+  const m = /^([a-z]{2,3})(?:[-_]([a-z]{2}))?$/i.exec(String(lang || '').trim());
+  return m ? m[1].toLowerCase() + (m[2] ? '-' + m[2].toUpperCase() : '') : 'en';
+}
+
+/** Skeletons and specs come in the built-in languages; other languages start from English. */
+export const templateLang = (lang) => (LANGUAGES.includes(normalizeLang(lang)) ? normalizeLang(lang) : 'en');
+
+/**
+ * Interface and document labels: English, then the built-in translation, then the workspace's own
+ * file (tadforce/i18n/<lang>.json) — the translation the agent writes for any other language.
+ */
+export function loadI18n(lang, ws = null) {
+  const l = normalizeLang(lang);
+  let dict = readJson(path.join(TEMPLATES, 'i18n', 'en.json'));
+  const builtIn = path.join(TEMPLATES, 'i18n', `${l}.json`);
+  if (l !== 'en' && exists(builtIn)) dict = merge(dict, readJson(builtIn));
+  const own = ws && path.join(ws, 'i18n', `${l}.json`);
+  if (own && exists(own)) dict = merge(dict, readJson(own));
+  return { lang: l, dict };
 }
 
 function merge(a, b) {
@@ -29,5 +44,6 @@ export function t(dict, key, vars = {}) {
 export function formatNumber(n, lang) {
   if (typeof n !== 'number' || !Number.isFinite(n)) return String(n);
   // fr-FR uses a narrow no-break space as thousands separator, as in the reference document.
-  return new Intl.NumberFormat(lang === 'fr' ? 'fr-FR' : 'en-US').format(n);
+  const locale = lang === 'fr' ? 'fr-FR' : lang === 'en' || !lang ? 'en-US' : lang;
+  try { return new Intl.NumberFormat(locale).format(n); } catch { return new Intl.NumberFormat('en-US').format(n); }
 }

package/README.fr.md

@@ -1,125 +0,0 @@
-<div align="center">
-
-<img src="assets/banner.svg" alt="TADForce" width="100%">
-
-### Le scribe de l'architecte pour les orgs Salesforce.
-
-**Quatre commandes. Une org. Un document d'architecture technique fondé sur des preuves, reproductible, relu dans le navigateur.**
-
-[English](README.md) · [**Démo en ligne**](https://azamiji.github.io/TADForce/)
-
-</div>
-
-<img src="assets/divider.svg" width="100%" alt="">
-
-## Pourquoi TADForce
-
-Rédiger le document d'architecture technique d'une org Salesforce prend des semaines, et il est périmé à la release suivante. Un chat IA générique l'écrit en une heure, puis on passe des jours à vérifier ce qu'il a inventé.
-
-TADForce lit l'org comme le ferait un architecte Salesforce senior — chaque classe, Flow, objet, Permission Set Group, Named Credential et OmniScript — et votre agent IA rédige le document à partir de ces preuves. Une seule règle : **pas de preuve, pas de phrase.** Si les métadonnées ne le prouvent pas, l'agent vous pose la question ou écrit « à confirmer ». Il ne devine jamais le nom d'un système, ne documente jamais une fonction décommissionnée et ne tape jamais un chiffre à la main.
-
-<div align="center">
-<img src="assets/gifs/document.gif" alt="Navigation dans un document généré par TADForce" width="92%">
-</div>
-
-## ⚡ Démarrage
-
-**Prérequis** : Node.js 20+, Salesforce CLI (`sf`), Chrome ou Edge, un agent IA. `doctor` vérifie tout et installe ce qu'il peut.
-
-À la racine de votre projet Salesforce DX (ou dans un dossier vide) :
-
-```bash
-npx tadforce doctor
-```
-
-Puis, dans votre agent IA (Claude Code, Codex, Cursor, Copilot…) :
-
-```text
-/tadforce
-```
-
-| Chemin | Commandes |
-|---|---|
-| Plugin Claude Code | `/plugin marketplace add azamiji/TADForce` puis `/plugin install tadforce@tadforce` |
-| Tout agent (Agent Skills) | `npx tadforce doctor` installe les skills dans `.claude/`, `.agents/`, `.cursor/`, `.codex/`… |
-| Déterministe / CI | `npx tadforce prepare --org prod`, puis `npx tadforce build --pdf --docx`, puis `npx tadforce validate` |
-
-## 🧭 Quatre commandes
-
-| Commande | Ce qu'elle fait | Votre part |
-|---|---|---|
-| `npx tadforce doctor` | Tout ce qui précède la rédaction, en boucle jusqu'à ce que tout soit vert : outils, projet SFDX, connexion à l'org (réutilise la `target-org` du projet, n'ouvre le navigateur que si nécessaire), métadonnées (récupérées depuis l'org avec un manifest `*`, ou vos sources locales), logo et couleurs du client, puis les questions dont seul un humain connaît la réponse | Vous connecter une fois ; valider les réponses recommandées ; nommer les systèmes externes ; confirmer ce qui est inutilisé ou décommissionné |
-| `npx tadforce build` | Votre agent rédige chaque section à partir de sa fiche et des faits, puis le document est produit : **HTML** toujours, **PDF** et **Word** à la demande, et validé | — |
-| `npx tadforce review` | Ouvre le document pour le commenter. **Enregistrer écrit dans le même fichier** : un seul fichier par document, pas de copies, aucun commentaire perdu. Puis `/tadforce-review` transforme chaque commentaire en correction | Commenter un passage ou capturer une zone, Enregistrer |
-| `npx tadforce update` | Quelques mois plus tard : relit l'org, archive les faits précédents, liste les sections touchées par ce qui a changé (une classe Apex ajoutée, un Flow modifié, de nouveaux chiffres…), incrémente la version. `/tadforce-update` ne réécrit que ces sections | — |
-
-<div align="center">
-<img src="assets/gifs/doctor.gif" alt="tadforce doctor pose les questions dont seul un humain connaît la réponse" width="80%">
-</div>
-
-Les commandes fines (`manifest`, `retrieve`, `facts`, `next`, `validate`…) restent disponibles pour la CI et les experts : `npx tadforce help --all`.
-
-## 📦 Ce que vous obtenez
-
-- **Document d'architecture technique**, destiné au client :
-  - en HTML : navigable, modifiable en place, avec commentaire d'un passage ou capture d'une zone, enregistrement dans le même fichier et export PDF ou Word ;
-  - en PDF A4 et en DOCX, la version dans le nom du fichier.
-- **Axes d'amélioration**, document interne à l'intégrateur : signaux mesurés par pilier Well-Architected, registre `AX-nn` et feuille de route. Ils restent hors du document client.
-- **`facts.json`** : l'inventaire déterministe de l'org, identique octet pour octet d'une exécution à l'autre.
-
-Le document porte **le logo et les couleurs du client** : le logo est cherché dans l'org (static resources, content assets, assets des sites) ou fourni par vous ; les couleurs viennent du thème Lightning de l'org, sinon du logo, toujours lisibles (contraste WCAG vérifié). L'intégrateur et l'auteur sont facultatifs : laissés vides, le document ne nomme que le client.
-
-<div align="center">
-<img src="assets/gifs/review.gif" alt="Commenter un passage dans le HTML et l'enregistrer dans le même fichier" width="92%">
-</div>
-
-## 🧩 Tous les types de projets Salesforce
-
-| Votre situation | Comment TADForce s'y adapte |
-|---|---|
-| **Une org complète**, état existant | `doctor` récupère tout avec un manifest `*` maîtrisé (130 types, rapports et tableaux de bord dans leurs dossiers, objets standard) |
-| **Un projet dans une org partagée** (plusieurs BU, plusieurs intégrateurs) | Périmètre : `--scope "NWB_*,Loan*"` ou `--package-dirs`. Les composants hors périmètre sortent des faits, des chiffres et des tableaux ; les objets standard et les réglages globaux restent |
-| **Avant ou pendant le build** | Fournissez vos spécifications fonctionnelles (`--specs SFD.pdf,…`) : elles deviennent des preuves (niveau P2/P3) à côté des métadonnées |
-| **Sans accès à l'org**, sources seules | `--source local` documente les package directories du projet |
-| **Packages unlocked ou managés** | Namespaces et packages installés sont détectés et documentés avec leurs preuves |
-| **Tous les clouds, toutes les industries** | Une section ne s'active que si le produit est détecté, avec sa fiche de rédaction |
-
-- **Clouds** : Sales, Service, Field Service, Experience, Marketing, Commerce, CPQ et Revenue ;
-- **Industries** : Financial Services, Insurance, Health, Life Sciences, Manufacturing, Automotive, Consumer Goods, Communications, Public Sector, Education, Nonprofit, Loyalty, Net Zero ;
-- **Plateforme** : OmniStudio, Data Cloud, Agentforce, CRM Analytics, Platform Events, Shield, MuleSoft, Heroku et Slack.
-
-## 🔒 Lecture seule par construction
-
-- **Liste blanche des commandes `sf`** : pas de deploy, pas de suppression, pas d'exécution d'Apex.
-- **Garde-fou SOQL** : seuls les objets de configuration de l'org et les agrégats sont lus, jamais les données métier.
-- **`force-app` jamais modifié** : la récupération se fait dans `tadforce/.snapshot`.
-- **Aucun secret dans le texte** : la validation bloque les secrets et les identifiants d'org.
-
-**Ce qui sort de votre poste** : le CLI TADForce n'envoie rien nulle part — ni télémétrie, ni serveur, ni compte. Il parle à votre org via votre propre Salesforce CLI, et au web seulement quand **vous** lui donnez l'URL d'un logo. Votre agent IA lit les métadonnées, les faits et les spécifications que vous fournissez pour rédiger, exactement comme lorsque vous lui faites lire votre code. Utilisez l'agent et les réglages de confidentialité validés par votre entreprise pour les travaux client.
-
-## 🎯 Reproductible
-
-- **Les chiffres sont des placeholders**, par exemple `{{n:apex.classes}}`.
-- **Les tableaux, les ERD, la hiérarchie des rôles et les annexes sont générés.**
-- **84 fiches de section** cadrent la rédaction de n'importe quel agent.
-- **`npx tadforce validate`** bloque tout ce qui ne doit pas être livré.
-
-## 👤 Auteur
-
-<table>
-<tr>
-<td width="110"><img src="https://github.com/azamiji.png" width="96" alt="Jihad AZAMI HASSANI"></td>
-<td>
-
-**Jihad AZAMI HASSANI**<br>
-Salesforce Technical Architect, 10+ ans d'expérience · Claude Certified Architect · Leader du Salesforce Architect Community Group de Casablanca<br>
-[![Claude Certified Architect](https://img.shields.io/badge/Claude-Certified%20Architect-D97757?logo=claude&logoColor=white)](https://www.linkedin.com/in/jihadazami/)<br>
-[LinkedIn](https://www.linkedin.com/in/jihadazami/) · [GitHub](https://github.com/azamiji)
-
-</td>
-</tr>
-</table>
-
-## ⚖️ Licence
-
-[Apache-2.0](LICENSE). Salesforce et les noms de ses produits sont des marques de Salesforce, Inc. TADForce est un projet communautaire indépendant, ni affilié à Salesforce ni approuvé par elle. L'organisation de l'exemple (Northwind Bank, Acme Integrators) est fictive.