agentplugged 1.0.6 → 1.3.0

package/dist/main.js

@@ -1,8 +1,8 @@
 import { n as SESSION_INSTANCE_ENV, r as SESSION_KEY_ENV, t as ENGINE_CHILD_ENV } from "./launcher-env.js";
-import { $ as engineEntry, A as resolveEngineCommand, B as planOf, C as codexHookHashes, D as questionToolHookIn, E as elicitationHookIn, F as STATE_CACHE_PATH, G as DEFAULT_THRESHOLDS, H as compare, I as evalStatus, J as casesDigest, K as EVALS_DIR, L as loadSkill, M as validateInstallChannel, N as writeInstallChannel, O as parseRootPin, P as detectGitWorkflow, Q as engineDir, R as suggestStarter, S as recordToolRead, T as planCodexTrust, U as keep, V as selection, W as CASES_FILE, X as ENGINE_PACKAGE, Y as readCases, Z as agentpluggedHome, _ as codexCallOf, a as NodeProofRunner, b as callOf, c as createCommandRegistry, f as envValue, g as CODEX_FLAVOR, h as cursorSessionOf, i as NodeMutationLab, j as readInstallChannel, k as rootPinText, l as ResponseMemory, m as cursorCallOf, n as productRootOf, nt as isReleaseVersion, o as NodeEvalAgent, p as CURSOR_FLAVOR, q as REFERENCE_FILE, r as NodeUsageTraces, s as NodeToolProbe, tt as isInstalledEngine, u as shapeResponse, v as codexSessionOf, w as codexTrustSupported, x as guardToolCall, y as recordCodexRead, z as evaluate } from "./product-root.js";
-import { Aa as DeferredIdInputSchema, Ao as resolveGitWorkflow, Bo as ErrorCode, Bt as journalRemoteRef, D as DeviationIdInputSchema, Do as GitBranchSchema, Eo as GIT_MERGE_MODES, Fo as ULID_PATTERN, Ft as JOURNAL_DIR, Io as eventInvalid, It as JOURNAL_REF, Ja as DEFAULT_VALIDATION_MODE, Ka as DEFAULT_INSTALL_MODE, Mo as EVENT_REASON, O as DeviationReasonSchema, P as TracedRequirementInputSchema, Pt as EVENT_TYPES, Qa as INSTALL_MODES, Ro as parseEventEnvelope, Sa as contentSections, Sr as QUESTION_TOOL_NAME, Vt as journalSeenRef, Xa as DEVELOPER_SPECIALTIES, Ya as DEFAULT_VALIDATION_POINTS, Za as DOMAIN_IDS, d as utf8, fo as TOOL_IDS, g as JOURNAL_PROJECTED_REF, ho as VALIDATION_POINTS, i as randomBytes, ko as recommendedGitWorkflow, l as toBase64url, mo as VALIDATION_MODES, no as PHASE_IDS, o as sha256Hex, qa as DEFAULT_PERMISSION_MODE, ro as PROFILE_PRESET_IDS, s as fromBase64url, to as PERMISSION_MODES, u as toHex, un as MAX_ELICITED_NOTE_LENGTH, wo as GIT_CI_MODES, zt as journalEventPath } from "./webauthn.js";
-import { $o as displayName, An as maybeAutoUpdate, Ar as AgentSession, Bo as publishedShape, Br as nextDeviceHead, Bu as waiverRefusal, Cn as withAnswers, Cs as formDigest, Ds as CI_CONFIG_PATHS, En as engineTargetOf, Eu as byOpening, Fd as creatorText, G as researchLines, Go as SKILL_OVERRIDES_DIR, Ha as renderCodexHooks, Ho as toolCallOf, Hr as prepareEngineEvents, Ir as checkHumanEvents, Iu as reviewActions, Ja as withEngineCommand, K as costsLines, Kr as forgetProductKey, Ku as METHOD_CONFIG_PATH, Lu as statusAt, Md as eventHash, Ml as ARCHITECTURE_SECURITY_REVIEW_PATH, Ms as isWorkflowFile, On as installAndPin, Os as GITHUB_WORKFLOWS_DIR, Pd as ANTIGRAVITY_UNCHECKED_REASON, Pr as createUlidFactory, Pu as parseWaiverAnswer, Qn as checkCreate, Ro as inputShapeOf, Rr as deviceHeads, Ru as waiverDeadlineProblem, Sn as runFix, Sr as COMMIT_STORIES_DIR, Ta as checkEngine, Td as normalizeChatText, Uo as toolNotation, Vo as TOOL_GROUPS, Vr as prepareAppend, Vu as AgentPluggedError, Wo as withToolNotation, Wr as announcedKey, Xn as AGENT_ACTIONS, Xr as sensitiveProductKey, _c as forgeOfHost$1, _r as CHAINED_HOOK_NAME, _s as keychainFull, ad as isAntigravityClient, au as STORY_BUILDERS, bc as remoteLocation, bn as displayCommand, br as COMMIT_HOOK_NAME, bs as DECISION_FORM_FIELDS, cd as isHookedClient, cr as recordGitWorkflow, dn as JournalBackup, es as toolName, fd as sameProject, fu as DEFAULT_PRESET, gc as forgeCli, io as methodNotInstalled, jd as canonicalBytes, jt as parseConflictMarkers, ku as ACTION_DECISIONS, ls as readDefinitions, mi as stackPromptDigest, mu as isPresetId, no as detectTools, od as isCodexClient, oo as readProfile, pu as inactiveAgents, qo as isPersonalLayerFile, ru as isRetiredDeveloper, sd as isCursorClient, so as resolveProfile, sr as validateCreateField, st as reviewNotInteractive, to as toolsFromDetection, ts as TOOL_CATALOG, ui as stackField, un as JOURNAL_REMOTE_NAME, vr as COMMIT_CHECK_PATH, vs as loadMachineKey, wd as messageDigest, xc as repositoryWebUrl, xr as COMMIT_SKIPS_PATH, yn as answerProblem, yr as COMMIT_HOOK_LINE, zr as journalProduct } from "./agent-commands.js";
-import { t as parsePresenceAttestation } from "./webauthn-verify2.js";
+import { $ as engineDir, A as resolveEngineCommand, B as planOf, C as codexHookHashes, D as questionToolHookIn, E as elicitationHookIn, F as STATE_CACHE_PATH, G as DEFAULT_THRESHOLDS, H as compare, I as evalStatus, J as casesDigest, K as EVALS_DIR, L as loadSkill, M as validateInstallChannel, N as writeInstallChannel, O as parseRootPin, P as detectGitWorkflow, Q as agentpluggedHome, R as suggestStarter, S as recordToolRead, T as planCodexTrust, U as keep, V as selection, W as CASES_FILE, X as productRootOf, Y as readCases, Z as ENGINE_PACKAGE, _ as codexCallOf, a as NodeProofRunner, b as callOf, c as createCommandRegistry, et as engineEntry, f as envValue, g as CODEX_FLAVOR, h as cursorSessionOf, i as NodeMutationLab, j as readInstallChannel, k as rootPinText, l as ResponseMemory, m as cursorCallOf, n as productRootOf$1, nt as isInstalledEngine, o as NodeEvalAgent, p as CURSOR_FLAVOR, q as REFERENCE_FILE, r as NodeUsageTraces, rt as isReleaseVersion, s as NodeToolProbe, u as shapeResponse, v as codexSessionOf, w as codexTrustSupported, x as guardToolCall, y as recordCodexRead, z as evaluate } from "./product-root.js";
+import { $o as EVENT_REASON, At as EVENT_TYPES, Br as QUESTION_TOOL_NAME, Fo as VALIDATION_POINTS, Ft as journalEventPath, Go as GIT_CI_MODES, It as journalRemoteRef, Jo as GitBranchSchema, Lt as journalSeenRef, Mo as TOOL_IDS, Mt as JOURNAL_REF, Po as VALIDATION_MODES, So as PROFILE_PRESET_IDS, Xo as recommendedGitWorkflow, Zo as resolveGitWorkflow, _n as TracedRequirementInputSchema, _o as INSTALL_MODES, a as fromBase64url, as as parseEventEnvelope, bo as PERMISSION_MODES, c as toHex, cn as MAX_ELICITED_NOTE_LENGTH, dn as DeviationReasonSchema, fo as DEFAULT_PERMISSION_MODE, g as JOURNAL_PROJECTED_REF, go as DOMAIN_IDS, ho as DEVELOPER_SPECIALTIES, i as sha256Hex, jt as JOURNAL_DIR, l as utf8, ls as ErrorCode, mo as DEFAULT_VALIDATION_POINTS, n as randomBytes, ns as ULID_PATTERN, po as DEFAULT_VALIDATION_MODE, qa as DeferredIdInputSchema, qo as GIT_MERGE_MODES, rs as eventInvalid, s as toBase64url, un as DeviationIdInputSchema, uo as DEFAULT_INSTALL_MODE, xo as PHASE_IDS, za as contentSections } from "./hash.js";
+import { $a as renderCodexHooks, $o as toolCallOf, An as engineTargetOf, Bd as canonicalBytes, Cn as answerProblem, Cr as COMMIT_HOOK_LINE, Cu as DEFAULT_PRESET, Dc as forgeCli, Dn as withAnswers, En as runFix, Er as COMMIT_STORIES_DIR, Fd as normalizeChatText, Fr as AgentSession, Ft as parseConflictMarkers, Gd as creatorText, Gr as nextDeviceHead, Iu as byOpening, J as researchLines, Ju as waiverDeadlineProblem, Kr as prepareAppend, Ku as reviewActions, Ma as checkEngine, Mc as repositoryWebUrl, Mn as installAndPin, Oc as forgeOfHost$1, Os as keychainFull, Pd as messageDigest, Pn as maybeAutoUpdate, Ps as formDigest, Qo as TOOL_GROUPS, Rs as CI_CONFIG_PATHS, Sd as sameProject, Sr as COMMIT_CHECK_PATH, Tr as COMMIT_SKIPS_PATH, Tu as isPresetId, Ul as ARCHITECTURE_SECURITY_REVIEW_PATH, Ur as deviceHeads, Us as isWorkflowFile, Vd as eventHash, Vr as checkHumanEvents, Wd as ANTIGRAVITY_UNCHECKED_REASON, Wr as journalProduct, Wu as parseWaiverAnswer, Xr as announcedKey, Xu as waiverRefusal, Y as costsLines, Yo as inputShapeOf, Yr as adoptRotatedKey, Zo as publishedShape, Zr as forgetProductKey, Zu as AgentPluggedError, _d as isCursorClient, _i as stackField, _o as readProfile, bs as readDefinitions, dr as validateCreateField, ds as toolName, dt as reviewNotInteractive, er as AGENT_ACTIONS, es as toolNotation, fo as toolsFromDetection, fr as recordGitWorkflow, fs as TOOL_CATALOG, gd as isCodexClient, gu as STORY_BUILDERS, hd as isAntigravityClient, hn as JournalBackup, ho as methodNotInstalled, is as isPersonalLayerFile, jc as remoteLocation, js as DECISION_FORM_FIELDS, ks as loadMachineKey, mn as JOURNAL_REMOTE_NAME, mu as isRetiredDeveloper, nd as METHOD_CONFIG_PATH, ni as sensitiveProductKey, nr as checkCreate, ns as SKILL_OVERRIDES_DIR, oo as withEngineCommand, po as detectTools, qr as prepareEngineEvents, qu as statusAt, ts as withToolNotation, us as displayName, vd as isHookedClient, vo as resolveProfile, wn as displayCommand, wr as COMMIT_HOOK_NAME, wu as inactiveAgents, xi as stackPromptDigest, xr as CHAINED_HOOK_NAME, zr as createUlidFactory, zs as GITHUB_WORKFLOWS_DIR, zu as ACTION_DECISIONS } from "./agent-commands.js";
+import { t as parsePresenceAttestation } from "./webauthn-verify.js";
 import { createRequire } from "node:module";
 import { constants, existsSync, realpathSync, statSync } from "node:fs";
 import { access, chmod, copyFile, link, lstat, mkdir, open, readFile, readdir, realpath, rename, rm, rmdir, stat, statfs, unlink, utimes, writeFile } from "node:fs/promises";
@@ -154,7 +154,7 @@ const UNSAFE_FOR_CMD = /["%!\r\n^&|<>]/;
 * How to run npm: the `npm-cli.js` that npm itself names or that sits next to this Node.js (no
 * shell), else the `npm` command of the PATH (through `cmd` on Windows, arguments quoted).
 */
-function npmProgram(env) {
+function npmProgram$1(env) {
 	const named = env.npm_execpath;
 	if (named !== void 0 && basename(named) === "npm-cli.js" && existsSync(named)) return {
 		program: process.execPath,
@@ -391,7 +391,7 @@ var NodeEngineUpdates = class {
 			env: this.#options.env,
 			timeoutMs: this.#options.installTimeoutMs ?? INSTALL_TIMEOUT_MS
 		};
-		const how = npmProgram(this.#options.env);
+		const how = npmProgram$1(this.#options.env);
 		if (!how.shell) return await runProgram$1(how.program, [...how.prefix, ...args], options);
 		const windows = process.platform === "win32";
 		if (windows && args.some((arg) => UNSAFE_FOR_CMD.test(arg))) return "no_npm";
@@ -580,9 +580,11 @@ function gitEnv() {
 /**
 * Runs one `git` command to completion. Rejects only when `git` cannot be started. `env` adds
 * variables (for example `LC_ALL=C`, so that messages can be recognised). After `timeoutMs`, the
-* process is killed and the run ends with `status: null` and `timedOut: true`.
+* process is killed and the run ends with `status: null` and `timedOut: true`. With `maxBytes`,
+* the process is killed once its output goes past that many bytes, and the run ends with
+* `capped: true` and the output cut at the limit.
 */
-function runGit(cwd, args, input, env = {}, timeoutMs) {
+function runGit(cwd, args, input, env = {}, timeoutMs, maxBytes) {
 	return new Promise((resolve, reject) => {
 		const child = spawn("git", args, {
 			cwd,
@@ -599,7 +601,20 @@ function runGit(cwd, args, input, env = {}, timeoutMs) {
 		}, timeoutMs);
 		const out = [];
 		const err = [];
-		child.stdout.on("data", (chunk) => out.push(chunk));
+		let size = 0;
+		let capped = false;
+		child.stdout.on("data", (chunk) => {
+			if (capped) return;
+			if (maxBytes !== void 0 && size + chunk.length > maxBytes) {
+				out.push(chunk.subarray(0, maxBytes - size));
+				size = maxBytes;
+				capped = true;
+				child.kill();
+				return;
+			}
+			size += chunk.length;
+			out.push(chunk);
+		});
 		child.stderr.on("data", (chunk) => err.push(chunk));
 		child.on("error", (error) => {
 			clearTimeout(timer);
@@ -609,10 +624,11 @@ function runGit(cwd, args, input, env = {}, timeoutMs) {
 			clearTimeout(timer);
 			const stderr = Buffer.concat(err).toString("utf8").trim();
 			resolve({
-				status: timedOut ? null : status,
+				status: timedOut ? null : capped ? 0 : status,
 				stdout: Buffer.concat(out),
 				stderr: timedOut ? `${stderr}\nfatal: git ${args[0] ?? ""} took more than ${Math.round((timeoutMs ?? 0) / 1e3)} s`.trim() : stderr,
-				timedOut
+				timedOut,
+				...capped ? { capped: true } : {}
 			});
 		});
 		child.stdin.on("error", () => {});
@@ -4296,9 +4312,20 @@ var GitStateStore = class {
 	async #append(drafts, precondition) {
 		const repo = await this.#repository();
 		const key = await this.#machineKey();
-		const productKey = await sensitiveProductKey(this.#options.keys, drafts);
+		let productKey = await sensitiveProductKey(this.#options.keys, drafts);
 		try {
-			return await this.#appendWith(repo, key, drafts, precondition, productKey);
+			try {
+				return await this.#appendWith(repo, key, drafts, precondition, productKey);
+			} catch (error) {
+				const product = drafts.find((draft) => draft.payload !== void 0)?.product;
+				if (productKey === void 0 || product === void 0 || !(error instanceof AgentPluggedError) || error.code !== ErrorCode.PRODUCT_KEY_MISMATCH) throw error;
+				const adopted = await adoptRotatedKey(this.#options.keys, product, await this.list());
+				await forgetProductKey(adopted);
+				if (adopted === void 0 || adopted.keyId === productKey.keyId) throw error;
+				await forgetProductKey(productKey);
+				productKey = await sensitiveProductKey(this.#options.keys, drafts);
+				return await this.#appendWith(repo, key, drafts, precondition, productKey);
+			}
 		} finally {
 			await forgetProductKey(productKey);
 		}
@@ -6890,6 +6917,8 @@ var PowerShellCredentials = class PowerShellCredentials {
 const KEYCHAIN_SERVICE = "agentplugged";
 /** Prefix of the product keys' accounts: `product:<product_id>`. */
 const PRODUCT_ACCOUNT = "product:";
+/** Prefix of the accounts of connection secrets: `connection:<name>`. */
+const CONNECTION_ACCOUNT = "connection:";
 function productAccount(productId) {
 	return `${PRODUCT_ACCOUNT}${productId}`;
 }
@@ -7098,6 +7127,18 @@ var NodeKeyStore = class {
 	writeProductBackup(productId, keyId, secret) {
 		return this.#write(`${productAccount(productId)}:previous:${keyId}`, secret);
 	}
+	readProductBackup(productId, keyId) {
+		return this.#read(`${productAccount(productId)}:previous:${keyId}`);
+	}
+	readConnectionSecret(name) {
+		return this.#read(`${CONNECTION_ACCOUNT}${name}`);
+	}
+	writeConnectionSecret(name, secret) {
+		return this.#write(`${CONNECTION_ACCOUNT}${name}`, secret);
+	}
+	deleteConnectionSecret(name) {
+		return explained(async () => (await this.#backend()).remove(this.service, `${CONNECTION_ACCOUNT}${name}`));
+	}
 	/** Deletes the machine key's entry; true when there was one. */
 	deleteMachineSecret() {
 		return explained(async () => (await this.#backend()).remove(this.service, this.account));
@@ -7111,7 +7152,7 @@ var NodeKeyStore = class {
 		if (this.service === "agentplugged") throw new Error(`deleteAll refuses the real keychain service ${KEYCHAIN_SERVICE}`);
 		let deleted = false;
 		const backend = await explained(() => this.#backend());
-		const products = await backend.accounts(this.service).then((found) => found.filter((name) => name.startsWith(PRODUCT_ACCOUNT))).catch(() => []);
+		const products = await backend.accounts(this.service).then((found) => found.filter((name) => name.startsWith("product:") || name.startsWith("connection:"))).catch(() => []);
 		for (const account of [
 			this.account,
 			this.humanAccount,
@@ -7510,7 +7551,7 @@ async function syncFolder(folder) {
 //#region ../../packages/i18n/dist/catalogs/en.js
 /** English catalog: the reference set of keys, and the fallback language. */
 const en = {
-	"cli.usage": "Usage: agentplugged <command> [options]\n\nFrom the chat: ask your agent, typed or dictated, for what only you decide (“pass the CI of story 4-3, the runner is down”):\n  it opens a request, you approve it in the chat, and the engine carries it out. The commands below also exist, for whoever prefers the command line; only the strict level requires them.\n\nCommands:\n  init      Install the method in the current folder\n  profile   Choose what the method does for this product (or in the chat)\n  doctor [--json] [--error <message>] [--exit-code <n>] [--report]  Look at your machine (Node, Git, the forge, your AI tools, the keychain…), say what is missing and repair it with your agreement; exit code 1 when a blocking point remains\n  sync      Generate the files of the AI tools (Claude Code, Codex, Antigravity CLI, Cursor) from the method\n  agent     Manage your agents and skills (or in the chat):\n              agent create <id>    create an agent (or a skill with --skill)\n              agent edit <id>      show the files to edit (creates the customisation file for a shipped agent or skill)\n              agent edit <skill> --personal\n                                   your own layer of a shipped skill, ignored by Git\n              agent edit <id> --tier <tier> --tool <tool>\n                                   choose the agent's model tier and preferred AI tool\n              agent enable <id>    activate an agent or a skill\n              agent disable <id>   deactivate an agent or a skill\n  journal sync  Bring the remote's journal into this one, then send it the events it lacks (never with force)\n  journal status  Show the state of the product computed from the journal: events applied, ignored, warnings\n                  (.agentplugged/.cache/state.json; its computed_at is the date of the last event applied, in projection order)\n  docs check  Check the documents of .agentplugged/docs, epics and stories: their headers, the stories (contract, coverage of the PRD, dependencies, approved intents), and that no requirement identifier was renumbered, reused or removed since the base (exit code 1 when problems are found, 2 when the check could not run)\n  mcp       Run the MCP server the agents report through, over stdio: a stable launcher that moves to a newer engine between two calls, without reconnecting (sync declares it in each AI tool)\n  update [--check on|off] [--auto on|off]  Install the latest engine in its own folder and bring the product to it (what a yes to Noah does; in an interactive terminal only); --check on|off: ask the npm registry whether a version is out, at most twice a day (on by default); --auto on|off: install it without a question (off by default)\n  hook antigravity|codex pre-tool|post-tool  The hooks of Antigravity CLI's plugin and of Codex's project, run by the tool: the permission rules before a tool, the reads of outside content after it (sync writes them)\n  publication <G-id> [--file <path>] [--raw]  Show the full text of a deliverable of launch, marketing or sales, the version you were shown (one file with --file; --raw: the file whole, header included)\n  publication export <G-id> [--force] [--unverified]  Write a deliverable you validated, ready to publish, in .agentplugged/exports/<G-id>/ (nothing is published, sent or paid)\n  review [<G-id>]  Answer an open checkpoint, signed by your key, or reopen one applied automatically (in an interactive terminal only)\n  key presence [--reset]  Protect your validations with Windows Hello (--reset: create the credential again when it no longer works)\n  key endorse [<human:…>]  List the creator keys waiting for an endorsement, or endorse one you trust\n  key export [--out <file>]  Export the product key, encrypted with a passphrase, for another machine\n  key import [--in <file>]  Import the product key exported on another machine (typed, not shown, without --in)\n  key seal  Encrypt the files of the Salle and of the memory still in clear\n  trust dismiss  Dismiss the event that blocks the orders when the journal holds another root of trust than the one pinned on this machine (nothing to do otherwise)\n                   (review, key and trust: in an interactive terminal only)\n  history   Show your validations, most recent first (--story <e-s>, --since <ISO date>, --decision <decision>;\n            --all: also the answers the journal ignored, with their reason)\n  history --export <file.json|file.csv> [--force]  Write them to a file (JSON or CSV, by its extension)\n  rules [show]  Show the permission rules: what agents do on their own (allow), after asking you (ask) or never (deny), read from the main branch\n  rules set <action> <allow|ask|deny>  Change one rule; rules reset: back to the defaults (in an interactive terminal only)\n  next      Show the next step in three lines: the current step, the agent to call and where, and what waits for your validation,\n            then a fourth line with the command to run when the step has one\n  migrate [--check]  Bring .agentplugged/ to the format of this engine and pin it, recorded in the journal (in an interactive terminal only; --check: show what it would do, without writing)\n  deferred [list] [<e-s>] [--all] [--json]  Show the open deferred work (the items that lock this story; --all: the closed ones too)\n  deferred show <D-id> [--json]  Show one deferred item\n  deferred resolve|drop <D-id> <reason>  Mark a deferred item done, or drop it (or in the chat; at the terminal: interactive only)\n  story start <e-s>  Start a story: its branch feat/<e-s>-<slug>, its working copy next to the repository and the commit hook (for you or an agent)\n  story pr <e-s>  Deliver a story: push its branch (never the main one) and open or update its pull request with the fixed template, through gh or glab already logged in\n  story ci <e-s> [--forge github|gitlab]  Read the CI of a story's open pull request (gh or glab); a failed CI sends the story back to development\n  story ci <e-s> --waive \"<reason>\"  Accept a story whose CI cannot be read, for its branch's current commit (or in the chat; at the terminal: interactive only)\n  ci setup [--forge github|gitlab]  Write the product's base CI (lint, tests, build, dependency audit), never over an existing CI\n  tests setup [--runner <name>] [--e2e <name>|none]  Plan the product's test framework from its files and propose, in .agentplugged/proofs.yaml, the command that runs the tests of a criterion (never over a declaration that exists)\n  trace [<EF-n>] [--json]  Show the traceability: every requirement with its status (to do, in development, in review, delivered, deviation), or one requirement with its stories, tests, pull requests and deviations\n  trace resolve <V-id> <reason>  Lift a deviation (or in the chat; at the terminal: interactive only)\n  usage [--by story|step|skill|agent|session] [--story <e-s>] [--since <day>] [--until <day>] [--session <tool>:<id>] [--json]  Show what your AI tools consumed: tokens and the origin of each figure (named by the tool, deduced from the journal, or unknown), the share nothing could attribute, the tools that cannot be measured; no amount of money, only a story's estimate\n  eval check [<skill>]  Check a skill's behaviour cases (valid, called by the words of its description, pass kept): free, no agent\n  eval init <skill>  Propose cases to start from, written once, never over a file that exists\n  eval run <skill> [--mode quality|baseline|variant|trigger] [--runs <n>] [--record] [--plan]  Run the cases with a real agent in a clean folder (it uses tokens: the plan comes first; never part of the tests), note them, count the tokens and compare with the pass kept: a case that no longer passes, or a cost over the threshold, makes it exit with 1\n  pair [--no-open] [--nouveau] [--changer-de-compte]  Link your web app to this product: shows a link to click, nothing else to do (the bridge does it, once installed)\n  bridge start|status  Run the bridge on this machine, or tell its state. The bridge is distributed apart, under the licence of Innovel Studio SASU: this command only launches it once installed\n\nOptions:\n  --profile <profile>   new-product, maintenance, launch-only or prototype, without questions\n  --validation <level>  init, profile: how you answer checkpoints, chat (in your AI tool's chat, the default), auto or strict\n  --installs <mode>     init, profile: how the dependencies are installed, visible (no validation, shown in the activity and written to the journal, the default) or validate (one validation each)\n  --points <list>       init, profile: the points of validation that wait for you (framing, architecture, breakdown, merge, release, publication, separated by commas; none: no point), the agents decide the others\n  --workflow recommended  init, profile: keep the recommended Git workflow for everything (a branch per story, the CI on the forge when there is one, merge by pull request, a review before the merge)\n  --branches <model>   init, profile: the base branches, main (alone), main+dev (stories land on dev, a release moves it into main) or <production>+<integration>\n  --story-branches <yes|no>  init, profile: a branch per story, or work on the branch the stories land on\n  --ci <mode>          init, profile: the CI, none, local (your machine) or remote (the forge)\n  --merge <mode>       init, profile: how a story is merged, pr (a pull request) or direct (by the engine, never pushed)\n  --review <yes|no>    init, profile: a review before the merge\n  --skill               agent create: create a skill instead of an agent\n  --name, --title, --description, --domain, --phase, --icon, --role <text>\n                        agent create: answers given without questions (a skill takes only --description)\n  --tier <tier>         agent edit: model tier, reasoning, code, fast or multimodal; `--tier default` goes back to the agent's own tier\n  --tool <tool>         agent edit: preferred AI tool, claude-code, codex, antigravity or cursor; `--tool none` removes the preferred tool\n  --remote <name>       journal sync: the Git remote to use (by default the one the current branch tracks, else origin)\n  --recreate-remote     journal sync: push the local journal as a new remote branch, after the remote one was deleted on purpose\n  --base <ref>          docs check: the Git version to compare with (HEAD by default)\n  --story <e-s>         history, usage: only this story (for example 2-6)\n  --since <date>        history, usage: from this date on: 2026-10-03 (local midnight), or a date and time with its offset, 2026-10-03T12:00:00Z or 2026-10-03T14:00:00+02:00\n  --by <axis>           usage: story, step (the default), skill, agent or session\n  --until <day>         usage: up to this day (YYYY-MM-DD, UTC), with --since\n  --session <tool>:<id> usage: also name what made this session dearer (skills loaded twice, files read again, tools failing; Claude Code only)\n  --decision <decision> history: approved, approved_with_reservations, rejected, changes_requested, option_chosen, waived or reopened\n  --all                 history: also the answers the journal ignored, with their reason (in the export too)\n  --export <file>       history: write to a .json file (exact) or a .csv file (for spreadsheets), relative to the current folder\n  --force               history --export, publication export: replace an existing file\n  --file <path>         publication: show only this file of the deliverable\n  --unverified          publication export: also export an approval given in the chat without proof (a tool without the hook)\n  --raw                 publication: the file whole, with the YAML header of the knowledge base\n  --error <message>    doctor: the message of the command that failed (`--error=<message>` when it starts with a dash; `-`: read from the standard input, piped); the engine says what it sees on your machine, apart from what it only supposes\n  --exit-code <n>      doctor: the exit code of the command that failed (137, 127…)\n  --report             doctor: the report to attach to a request for help (system, versions, result of every check), with no user name, personal path, token or product content; it repairs nothing\n  --json                next, deferred, trace, usage, doctor: the answer in JSON, for scripts (an error too, on standard output, except doctor)\n  --yes, -y             init: asks nothing, takes the recommended answers (and writes the AI tools' files); with a script, the exit code says whether a blocking point remains\n  --tools <list>        init: the AI tools to wire in, among claude-code, codex, antigravity and cursor, separated by commas (by default those found, else all)\n  --permissions <mode>  init, profile: protected (default: your AI tool keeps asking before sensitive gestures) or free (its mode without questions stays possible)\n  --channel <store>     init: the store the method was found in (claude-plugin), written by the welcome skill of the Claude Code plugin so that `doctor` says how the method was installed\n  --no-sync             init: does not write the AI tools' files\n  --out <file>          key export: write the exported key to this new file, outside the repository\n  --in <file>           key import: read the exported key from this file\n  --check               migrate: show what it would do, without writing anything\n  --forge <forge>       ci setup, story ci: github or gitlab (by default, ci.forge of method.yaml, else the forge of the origin remote)\n  --runner <name>       tests setup: the unit and API runner (vitest, jest, mocha, node-test, pytest, go-test, cargo-test, rspec, phpunit, dotnet-test, maven, gradle)\n  --e2e <name>          tests setup: the end-to-end runner (playwright, cypress) or none\n  --waive <reason>      story ci: accept the story without its CI, for its branch's current commit\n  --upgrade-engine      init: pin the running engine version in `.agentplugged/method.yaml` and refresh the method (not recorded in the journal: for an engine bump alone, prefer `migrate`)\n  --engine-any          run even when `.agentplugged/method.yaml` pins another engine version (with a warning)\n  --version, -v         print the version of agentplugged\n  --help, -h            print this help",
+	"cli.usage": "Usage: agentplugged <command> [options]\n\nFrom the chat: ask your agent, typed or dictated, for what only you decide (“pass the CI of story 4-3, the runner is down”):\n  it opens a request, you approve it in the chat, and the engine carries it out. The commands below also exist, for whoever prefers the command line; only the strict level requires them.\n\nCommands:\n  init      Install the method in the current folder\n  profile   Choose what the method does for this product (or in the chat)\n  doctor [--json] [--error <message>] [--exit-code <n>] [--report]  Look at your machine (Node, Git, the forge, your AI tools, the keychain…), say what is missing and repair it with your agreement; exit code 1 when a blocking point remains\n  sync      Generate the files of the AI tools (Claude Code, Codex, Antigravity CLI, Cursor) from the method\n  agent     Manage your agents and skills (or in the chat):\n              agent create <id>    create an agent (or a skill with --skill)\n              agent edit <id>      show the files to edit (creates the customisation file for a shipped agent or skill)\n              agent edit <skill> --personal\n                                   your own layer of a shipped skill, ignored by Git\n              agent edit <id> --tier <tier> --tool <tool>\n                                   choose the agent's model tier and preferred AI tool\n              agent enable <id>    activate an agent or a skill\n              agent disable <id>   deactivate an agent or a skill\n  journal sync  Bring the remote's journal into this one, then send it the events it lacks (never with force)\n  journal status  Show the state of the product computed from the journal: events applied, ignored, warnings\n                  (.agentplugged/.cache/state.json; its computed_at is the date of the last event applied, in projection order)\n  docs check  Check the documents of .agentplugged/docs, epics and stories: their headers, the stories (contract, coverage of the PRD, dependencies, approved intents), and that no requirement identifier was renumbered, reused or removed since the base (exit code 1 when problems are found, 2 when the check could not run)\n  mcp       Run the MCP server the agents report through, over stdio: a stable launcher that moves to a newer engine between two calls, without reconnecting (sync declares it in each AI tool)\n  update [--check on|off] [--auto on|off]  Install the latest engine in its own folder and bring the product to it (what a yes to Noah does; in an interactive terminal only); --check on|off: ask the npm registry whether a version is out, at most twice a day (on by default); --auto on|off: install it without a question (off by default)\n  hook antigravity|codex pre-tool|post-tool  The hooks of Antigravity CLI's plugin and of Codex's project, run by the tool: the permission rules before a tool, the reads of outside content after it (sync writes them)\n  publication <G-id> [--file <path>] [--raw]  Show the full text of a deliverable of launch, marketing or sales, the version you were shown (one file with --file; --raw: the file whole, header included)\n  publication export <G-id> [--force] [--unverified]  Write a deliverable you validated, ready to publish, in .agentplugged/exports/<G-id>/ (nothing is published, sent or paid)\n  review [<G-id>]  Answer an open checkpoint, signed by your key, or reopen one applied automatically (in an interactive terminal only)\n  key presence [--reset]  Protect your validations with Windows Hello (--reset: create the credential again when it no longer works)\n  key endorse [<human:…>]  List the creator keys waiting for an endorsement, or endorse one you trust\n  key export [--out <file>]  Export the product key, encrypted with a passphrase, for another machine\n  key import [--in <file>]  Import the product key exported on another machine (typed, not shown, without --in)\n  key seal  Encrypt the files of the Salle and of the memory still in clear\n  trust dismiss  Dismiss the event that blocks the orders when the journal holds another root of trust than the one pinned on this machine (nothing to do otherwise)\n                   (review, key and trust: in an interactive terminal only)\n  history   Show your validations, most recent first (--story <e-s>, --since <ISO date>, --decision <decision>;\n            --all: also the answers the journal ignored, with their reason)\n  history --export <file.json|file.csv> [--force]  Write them to a file (JSON or CSV, by its extension)\n  rules [show]  Show the permission rules: what agents do on their own (allow), after asking you (ask) or never (deny), read from the main branch\n  rules set <action> <allow|ask|deny>  Change one rule; rules reset: back to the defaults (in an interactive terminal only)\n  next      Show the next step in three lines: the current step, the agent to call and where, and what waits for your validation,\n            then a fourth line with the command to run when the step has one\n  migrate [--check]  Bring .agentplugged/ to the format of this engine and pin it, recorded in the journal (in an interactive terminal only; --check: show what it would do, without writing)\n  deferred [list] [<e-s>] [--all] [--json]  Show the open deferred work (the items that lock this story; --all: the closed ones too)\n  deferred show <D-id> [--json]  Show one deferred item\n  deferred resolve|drop <D-id> <reason>  Mark a deferred item done, or drop it (or in the chat; at the terminal: interactive only)\n  story start <e-s>  Start a story: its branch feat/<e-s>-<slug>, its working copy next to the repository and the commit hook (for you or an agent)\n  story pr <e-s>  Deliver a story: push its branch (never the main one) and open or update its pull request with the fixed template, through gh or glab already logged in\n  story ci <e-s> [--forge github|gitlab]  Read the CI of a story's open pull request (gh or glab); a failed CI sends the story back to development\n  story ci <e-s> --waive \"<reason>\"  Accept a story whose CI cannot be read, for its branch's current commit (or in the chat; at the terminal: interactive only)\n  ci setup [--forge github|gitlab]  Write the product's base CI (lint, tests, build, dependency audit), never over an existing CI\n  tests setup [--runner <name>] [--e2e <name>|none]  Plan the product's test framework from its files and propose, in .agentplugged/proofs.yaml, the command that runs the tests of a criterion (never over a declaration that exists)\n  trace [<EF-n>] [--json]  Show the traceability: every requirement with its status (to do, in development, in review, delivered, deviation), or one requirement with its stories, tests, pull requests and deviations\n  trace resolve <V-id> <reason>  Lift a deviation (or in the chat; at the terminal: interactive only)\n  usage [--by story|step|skill|agent|session] [--story <e-s>] [--since <day>] [--until <day>] [--session <tool>:<id>] [--json]  Show what your AI tools consumed: tokens and the origin of each figure (named by the tool, deduced from the journal, or unknown), the share nothing could attribute, the tools that cannot be measured; no amount of money, only a story's estimate\n  eval check [<skill>]  Check a skill's behaviour cases (valid, called by the words of its description, pass kept): free, no agent\n  eval init <skill>  Propose cases to start from, written once, never over a file that exists\n  eval run <skill> [--mode quality|baseline|variant|trigger] [--runs <n>] [--record] [--plan]  Run the cases with a real agent in a clean folder (it uses tokens: the plan comes first; never part of the tests), note them, count the tokens and compare with the pass kept: a case that no longer passes, or a cost over the threshold, makes it exit with 1\n  pair [--no-open] [--nouveau] [--changer-de-compte]  Link your web app to this product: shows a link to click, nothing else to do (the bridge does it, once installed)\n  device list|revoke <device>  List the devices linked to this product, or remove one: it receives nothing more and can be linked again (the bridge does it, once installed)\n  bridge install|uninstall|start|status  Install the bridge (and update it) as a service of your account, remove it, run it on this machine, or tell its state. The bridge is distributed apart, under the licence of Innovel Studio SASU: this command only installs and launches it\n\nOptions:\n  --profile <profile>   new-product, maintenance, launch-only or prototype, without questions\n  --validation <level>  init, profile: how you answer checkpoints, chat (in your AI tool's chat, the default), auto or strict\n  --installs <mode>     init, profile: how the dependencies are installed, visible (no validation, shown in the activity and written to the journal, the default) or validate (one validation each)\n  --points <list>       init, profile: the points of validation that wait for you (framing, architecture, breakdown, merge, release, publication, separated by commas; none: no point), the agents decide the others\n  --workflow recommended  init, profile: keep the recommended Git workflow for everything (a branch per story, the CI on the forge when there is one, merge by pull request, a review before the merge)\n  --branches <model>   init, profile: the base branches, main (alone), main+dev (stories land on dev, a release moves it into main) or <production>+<integration>\n  --story-branches <yes|no>  init, profile: a branch per story, or work on the branch the stories land on\n  --ci <mode>          init, profile: the CI, none, local (your machine) or remote (the forge)\n  --merge <mode>       init, profile: how a story is merged, pr (a pull request) or direct (by the engine, never pushed)\n  --review <yes|no>    init, profile: a review before the merge\n  --skill               agent create: create a skill instead of an agent\n  --name, --title, --description, --domain, --phase, --icon, --role <text>\n                        agent create: answers given without questions (a skill takes only --description)\n  --tier <tier>         agent edit: model tier, reasoning, code, fast or multimodal; `--tier default` goes back to the agent's own tier\n  --tool <tool>         agent edit: preferred AI tool, claude-code, codex, antigravity or cursor; `--tool none` removes the preferred tool\n  --remote <name>       journal sync: the Git remote to use (by default the one the current branch tracks, else origin)\n  --recreate-remote     journal sync: push the local journal as a new remote branch, after the remote one was deleted on purpose\n  --base <ref>          docs check: the Git version to compare with (HEAD by default)\n  --story <e-s>         history, usage: only this story (for example 2-6)\n  --since <date>        history, usage: from this date on: 2026-10-03 (local midnight), or a date and time with its offset, 2026-10-03T12:00:00Z or 2026-10-03T14:00:00+02:00\n  --by <axis>           usage: story, step (the default), skill, agent or session\n  --until <day>         usage: up to this day (YYYY-MM-DD, UTC), with --since\n  --session <tool>:<id> usage: also name what made this session dearer (skills loaded twice, files read again, tools failing; Claude Code only)\n  --decision <decision> history: approved, approved_with_reservations, rejected, changes_requested, option_chosen, waived or reopened\n  --all                 history: also the answers the journal ignored, with their reason (in the export too)\n  --export <file>       history: write to a .json file (exact) or a .csv file (for spreadsheets), relative to the current folder\n  --force               history --export, publication export: replace an existing file\n  --file <path>         publication: show only this file of the deliverable\n  --unverified          publication export: also export an approval given in the chat without proof (a tool without the hook)\n  --raw                 publication: the file whole, with the YAML header of the knowledge base\n  --error <message>    doctor: the message of the command that failed (`--error=<message>` when it starts with a dash; `-`: read from the standard input, piped); the engine says what it sees on your machine, apart from what it only supposes\n  --exit-code <n>      doctor: the exit code of the command that failed (137, 127…)\n  --report             doctor: the report to attach to a request for help (system, versions, result of every check), with no user name, personal path, token or product content; it repairs nothing\n  --json                next, deferred, trace, usage, doctor: the answer in JSON, for scripts (an error too, on standard output, except doctor)\n  --yes, -y             init: asks nothing, takes the recommended answers (and writes the AI tools' files); with a script, the exit code says whether a blocking point remains\n  --tools <list>        init: the AI tools to wire in, among claude-code, codex, antigravity and cursor, separated by commas (by default those found, else all)\n  --permissions <mode>  init, profile: protected (default: your AI tool keeps asking before sensitive gestures) or free (its mode without questions stays possible)\n  --channel <store>     init: the store the method was found in (claude-plugin), written by the welcome skill of the Claude Code plugin so that `doctor` says how the method was installed\n  --no-sync             init: does not write the AI tools' files\n  --clean-gemini        sync: remove only the files AgentPlugged wrote for the retired Gemini CLI, and list the others (with --yes: remove those too)\n  --out <file>          key export: write the exported key to this new file, outside the repository\n  --in <file>           key import: read the exported key from this file\n  --check               migrate: show what it would do, without writing anything\n  --forge <forge>       ci setup, story ci: github or gitlab (by default, ci.forge of method.yaml, else the forge of the origin remote)\n  --runner <name>       tests setup: the unit and API runner (vitest, jest, mocha, node-test, pytest, go-test, cargo-test, rspec, phpunit, dotnet-test, maven, gradle)\n  --e2e <name>          tests setup: the end-to-end runner (playwright, cypress) or none\n  --waive <reason>      story ci: accept the story without its CI, for its branch's current commit\n  --upgrade-engine      init: pin the running engine version in `.agentplugged/method.yaml` and refresh the method (not recorded in the journal: for an engine bump alone, prefer `migrate`)\n  --engine-any          run even when `.agentplugged/method.yaml` pins another engine version (with a warning)\n  --version, -v         print the version of agentplugged\n  --help, -h            print this help",
 	"cli.error": "Error {code}: {message}",
 	"init.summary.title": "Method installed in {root}",
 	"init.action.created": "created",
@@ -7549,6 +7590,10 @@ const en = {
 	"sync.warning.overwritten": "{path}: manual modification overwritten.",
 	"sync.warning.conflict": "{path}: no agentplugged mark (a header, or the generated description of a plugin), so it is yours and was left as is. Rename or remove it to let sync generate it.",
 	"sync.warning.kept": "{path}: no longer generated, but its header was removed, so it is yours and was kept.",
+	"sync.warning.gemini_legacy": "Gemini CLI is no longer supported by Google; AgentPlugged now uses Antigravity CLI. Your old Gemini CLI files ({path}) are still read and are left as they are: nothing is written or removed there. To remove only the files AgentPlugged wrote, run `npx agentplugged sync --clean-gemini`.",
+	"sync.warning.gemini_unproven": "{path}: AgentPlugged cannot prove it wrote this as it is (changed since, or no trace of it), so it was kept.",
+	"sync.gemini.confirm": "The files above were kept. To remove them too, check them, then run `npx agentplugged sync --clean-gemini --yes`.",
+	"sync.gemini.nothing": "Nothing to clean: no file written by AgentPlugged for Gemini CLI was found.",
 	"tools.title": "AI tools",
 	"tools.line": "{name} {version} — {sources}",
 	"tools.line.unknown_version": "{name} (version not recognized) — {sources}",
@@ -7977,7 +8022,7 @@ const en = {
 	"history.author.root": "{device} (root key)",
 	"history.author.endorsed": "{device} (endorsed on {date})",
 	"history.author.endorsed_undated": "{device} (endorsed)",
-	"history.source.terminal": "terminal",
+	"history.source.terminal": "at the terminal",
 	"history.option": "option {option}",
 	"history.waiver_until": "until {date}",
 	"history.assurance": "assurance {assurance}",
@@ -8044,6 +8089,10 @@ const en = {
 	"key.export.hint": "On the other machine, run `npx agentplugged key import` (or `--in <file>`) and type the same passphrase. Keep the passphrase safe: without it the export is useless, and a lost product key makes the encrypted content unreadable for ever.",
 	"key.import.done": "Product key {key_id} imported into this machine's keychain.",
 	"key.import.already": "This machine already holds the product key {key_id}.",
+	"key.export.many": "This export holds {count} keys: the current one and the ones kept from before each renewal, so the whole history is readable wherever you import it.",
+	"key.export.missing": "Warning: this machine does not hold {count} older key(s) of this product ({key_ids}). What they wrote cannot be read from this export; export from a machine that holds them.",
+	"key.import.many": "Keys kept on this machine: {key_ids}.",
+	"key.import.older": "Older keys of the product imported: the history written under them is readable. The current key {key_id} is still missing here: import an export made after the last renewal, or let the renewal reach this machine.",
 	"init.product_key.created": "Product key created ({key_id}): costs, security notes, the Salle and the memory are encrypted with it. It stays in this machine's keychain, never in the repository.",
 	"init.product_key.ready": "Product key: {key_id}.",
 	"init.product_key.published": "Its identifier is announced in this product's journal.",
@@ -8260,6 +8309,7 @@ const en = {
 	"next.step.knowledge_base": "Generate the knowledge base",
 	"next.step.knowledge_base_review": "Knowledge base waiting for your review",
 	"next.step.knowledge_base_decision": "Answer Zoé about the knowledge base",
+	"next.step.paused": "The team is paused: resume it when you are ready",
 	"reason.docSource": "a list of { path, blob }: the path of a document read, and the blob id of the version read (40 or 64 lowercase hexadecimal characters)",
 	"docs.check.warning.kb_stale": "the knowledge base page {path} was built from another version of {source} (blob {recorded}) than the one validated in {checkpoint} (blob {blob}): Zoé updates it.",
 	"docs.check.warning.kb_source_unrecorded": "the knowledge base page {path} relies on {source}, validated in {checkpoint} (blob {blob}), without recording the version read (`sources` in its header): Zoé updates it.",
@@ -8330,6 +8380,7 @@ const en = {
 	"error.story_not_startable.not_builder": "{agent} does not build story {story}: its builder is {owner} (its owner, or an agent of the sprint's capacity).",
 	"error.story_not_startable.started_by_other": "Story {story} was started by {agent}: a story never has two developers, only {agent} takes it up again.",
 	"error.story_not_startable.parallel_limit": "Story {story} waits: {limit} stories are already being built at once ({building}), the ceiling of the profile (max_parallel_stories). Start it once one of them is done. Nothing was created.",
+	"error.story_not_startable.team_paused": "The team is paused: story {story} does not start until the creator resumes it. Nothing was created.",
 	"error.story_not_startable.unsupported_repository": "This repository cannot hold a story's working copy ({why}: a bare repository, or one at the root of a disk). Nothing was created.",
 	"error.story_not_startable.not_recorded": "Branch {branch} and the working copy {path} were created, but nothing was recorded ({cause}): run the same command again.",
 	"error.journal_busy_replanned": "The journal kept changing while {command} was checked ({attempts} attempts): nothing was written. Call it again in a moment.",
@@ -8544,6 +8595,8 @@ const en = {
 	"error.delegation_invalid.skill_autonomous": "The skill {to} has no sub-agent of its own: hand it over in the conversation. Nothing was written.",
 	"error.delegation_invalid.story_required": "{to} is a developer: it works on a story, one instance per story. Give the story. Nothing was written.",
 	"error.delegation_invalid.story_taken": "Story {story} is already built by {agent}: a story never has two developers. Nothing was written.",
+	"error.team_already_paused": "The team is already paused since {since}: there is nothing more to hold. Nothing was written.",
+	"error.delegation_invalid.team_paused": "The team is paused: nothing is handed over to {to} until the creator resumes it. Nothing was written.",
 	"error.delegation_invalid.parallel_limit": "The ceiling of {limit} stories in parallel is reached ({building}): story {story} waits until one of them is done. Nothing was written.",
 	"checkpoint.type.creator_action": "creator's action",
 	"creator_action.kind.ci_waive": "accept a story without its CI",
@@ -9069,9 +9122,29 @@ const en = {
 	"error.relay.relay_connection_replaced": "A newer connection of this device replaced this one.",
 	"error.relay.relay_prekey_invalid": "The relay refused this receiving key. Nothing was kept.",
 	"error.relay.relay_unavailable": "The relay could not do this right now. Nothing was done: try again.",
+	"error.relay.vault_refused": "The relay did not keep the last state of your project. Your machine seals it again.",
+	"error.relay.push_refused": "The relay did not take this notification request. Nothing was sent.",
 	"error.relay.rendezvous_unknown": "This pairing link no longer exists. Run the command again to get a new one.",
 	"error.relay.rendezvous_refused": "The relay could not open this rendezvous. Try again in a moment.",
 	"error.relay.rendezvous_attach_refused": "The relay could not attach this machine to your account. Try again with a new link.",
+	"error.relay.challenge_expired": "This step took too long. Start again.",
+	"error.relay.challenge_reused": "This step was already used. Start again.",
+	"error.relay.origin_mismatch": "This page is not allowed to use your passkey with AgentPlugged. Open the official address.",
+	"error.relay.credential_already_registered": "This passkey already belongs to an account. Sign in with it instead.",
+	"error.relay.email_code_invalid": "That code is not right. Check the e-mail and try again.",
+	"error.relay.email_code_expired": "That code is no longer valid. Ask for a new code.",
+	"error.relay.email_already_registered": "An account already exists with this address. Sign in with your passkey.",
+	"error.relay.account_request_invalid": "The request is not valid. Check what you typed.",
+	"error.relay.account_sign_in_failed": "This passkey was not recognized. Try again, or use another device.",
+	"error.relay.account_session_required": "You are signed out. Sign in again.",
+	"error.relay.account_deleted": "This account was deleted: this device is no longer linked to it.",
+	"error.relay.export_not_ready": "Your export is still being prepared. Try again in a moment.",
+	"error.relay.export_gone": "This export was already downloaded, or its link has expired. Ask for a new one.",
+	"error.relay.passkey_limit": "You already have the most passkeys an account may hold. Remove one before adding another.",
+	"error.relay.passkey_last": "This is your last passkey: without one, nobody could sign in to this account. Add another first.",
+	"error.relay.share_limit": "You already have the most share links active. Withdraw one before making another.",
+	"error.relay.share_too_large": "This page is too large to be shared.",
+	"error.relay.share_unavailable": "This link does not work: it has expired or was withdrawn.",
 	"error.relay.upgrade_required": "This device speaks a version of the protocol that the relay no longer accepts: update it.",
 	"points.title": "The points of validation: the ones you keep for yourself. Every other point is decided by the agent responsible for it, with its reason in the journal, and you can reopen it whenever you want.",
 	"points.point.framing": "Framing documents (brief, PRD, UX specification) and the end of their phases",
@@ -9084,10 +9157,15 @@ const en = {
 	"points.summary": "Points that wait for you: {list}. The agents decide the others.",
 	"points.summary.none": "No point waits for you: the agents decide every point.",
 	"history.source.agent": "decided by the agent responsible",
+	"history.source.web": "from the web view",
+	"history.source.mobile": "from the phone",
 	"assurance.agent": "an agent's decision (not your answer), with its reason; you can reopen it",
+	"assurance.device": "signed by a device you linked (the web view or your phone)",
 	"review.agent_decided": "Decided by the agent {agent} on {at}: {decision}. Reason: {reason}",
 	"next.step.point_decision": "A point you do not keep waits for the agent responsible to decide it",
 	"next.independent": "The work goes on without you: this step does not depend on any of the points that wait for you.",
+	"next.paused": "The team is paused since {since}. Each agent finishes the step it is on and starts nothing new; resume it from the web view, the phone, or by asking Noah.",
+	"next.paused.stopped": "The team was stopped in an emergency since {since}: the programs the bridge started were cut, and nothing starts until you resume it.",
 	"next.stop": "Nothing independent is left: the points that wait for you block what follows, the agents stop here.",
 	"next.morning": "Since your last validation: {done} story(ies) done, {decided} point(s) decided by the agents, {waiting} point(s) waiting for you.",
 	"docs.check.skipped": "Skipped step (warning): {path}:{line}: {code}: {message}",
@@ -9137,7 +9215,10 @@ const en = {
 	"update.done_pinned": "Engine {version} is installed (the product already pinned it). Your open sessions move to it at their next call.",
 	"update.failed": "The update did not happen ({reason}). {message} The running engine was not touched.",
 	"error.engine_version_too_old.agent": "{path} pins engine {pinned} and this session still runs {engine_version}: nothing was written. Call `state.next` (or `state.get`): it carries `engine_update`, and the creator's one « oui » to guard.creator_action `engine_update` {install: true} installs {pinned} and moves this session to it at your next call. Say it to the creator in one sentence; never tell them to reconnect or to type a command.",
-	"bridge.launcher.not_installed": "The bridge is not installed on this machine. It is distributed apart, under the licence of Innovel Studio SASU: get it at https://agentplugged.ai. The rest of AgentPlugged (`state.next`, `review`, the MCP server) works without it.",
+	"bridge.launcher.not_installed": "The bridge is not installed on this machine. It is distributed apart, under the licence of Innovel Studio SASU: install it with `agentplugged bridge install` (details at https://agentplugged.ai). The rest of AgentPlugged (`state.next`, `review`, the MCP server) works without it.",
+	"bridge.launcher.installing": "Getting the bridge (the newest version)…",
+	"bridge.launcher.install_failed": "The bridge could not be downloaded ({reason}). Nothing was installed. Try again, or get it at https://agentplugged.ai.",
+	"bridge.launcher.update_failed": "The newest bridge could not be downloaded ({reason}): the installed one is kept.",
 	"workflow.title": "Git workflow (branches, CI, merges, review)",
 	"workflow.recommended": "(recommended)",
 	"workflow.intro": "I propose what suits a solo creator: {line}. Answer yes to keep it all, or no to choose each point.",
@@ -9305,6 +9386,7 @@ const en = {
 	"init.sync.done": "Files of your AI tools written ({count} created or updated).",
 	"init.sync.skipped": "No sync for now: run `npx agentplugged sync` whenever you want.",
 	"init.done.noah": "Ready. Open {tool} in this folder and write: noah ?",
+	"init.link.hint": "To link it to your web app: `npx agentplugged pair`",
 	"init.done.noah.several": "Ready. Open one of your tools ({tools}) in this folder and write: noah ?",
 	"init.done.sync_first": "Next: run `npx agentplugged sync`, then open {tool} in this folder and write: noah ?",
 	"init.done.sync_first.several": "Next: run `npx agentplugged sync`, then open one of your tools ({tools}) in this folder and write: noah ?",
@@ -9389,7 +9471,6 @@ const FALLBACK_REASONS = { fr: {
 	"codex.untrusted": "les hooks de Codex enregistrent une lecture faite par une commande réseau (`curl`, `wget`, `gh`, `git pull`…) ou par un outil d'un autre serveur MCP. La recherche web propre à Codex est un outil hébergé que les hooks ne voient pas : après une recherche web, l'agent appelle `guard.external_read` pour que le journal en garde la trace (source, heure, agent) ; rien n'est bloqué. Les actions faites par les outils de fichiers (lire, modifier, écrire) ne passent pas par un hook de lecture : seules les règles de permission les encadrent (`read_secrets` est toujours refusé). Seul Claude Code contrôle aussi une écriture avant qu'elle ait lieu (un secret, un fichier hors de la story, une décision d'architecture) : pas cet outil.",
 	"codex.isolation": "les fichiers d'agents de cet outil ne savent pas lancer un développeur dans une copie de travail à lui : chaque développeur travaille seulement dans le `workdir` que renvoie `story.start`, la copie de travail propre à la story, une par story. Le bac à sable de Codex garde aussi les écritures dans le dossier du projet, et la copie de travail d'une story est à côté (`<projet>.worktrees/<id>`) : un développeur n'y écrit que si `sandbox_workspace_write.writable_roots` de Codex la liste par son chemin absolu (observé sur Codex 0.160.1, le 2026-10-06 : un chemin relatif est lu depuis le dossier du projet et son `..` est ignoré ; `~/` fonctionne), ce que `sync` n'écrit pas parce que le moteur ne sait pas où se trouve le projet sur cette machine. Sous Windows, Codex ne laisse écrire dans le projet qu'une fois son bac à sable Windows installé (le mode élevé, une approbation d'administrateur, proposée par l'extension d'éditeur) : sinon la session retombe en silence en lecture seule, et le mode non élevé refuse un projet dont `.git` et `.codex` sont protégés.",
 	"codex.decisions": "Codex n'envoie à son client les formulaires qu'un serveur MCP demande (« elicitation ») que si sa politique d'approbation les laisse passer : un `never` seul les refuse en silence, d'où la forme granulaire que `sync` écrit et qui refuse tout le reste (observé sur Codex 0.160.1, le 2026-10-06, par son serveur d'application : la demande arrive au client, dont le moteur enregistre la réponse). `codex exec` les refuse, et aucun n'a été vu affiché à l'écran de l'extension d'éditeur : les décisions te sont posées en texte dans le chat (« a, b ou c ? »), et l'agent enregistre ta réponse avec `chat.answer`, en la citant. Le moteur essaie quand même le formulaire d'abord (`chat.ask`) et passe au chat quand l'outil ne peut pas l'afficher.",
-	"gemini-cli.permissions": "agentplugged ne génère aucun fichier de permissions pour Gemini CLI : aucun chemin n'est bloqué.",
 	"cursor.permissions.hooks-kept": "sync n'a pas pu écrire `.cursor/hooks.json` (le fichier est à toi) : aucun hook n'applique les chemins et les commandes protégés dans l'éditeur Cursor. `.cursorignore` garde les secrets hors de portée de l'agent, et `.cursor/cli.json` bloque les chemins interdits dans la CLI de Cursor seulement (l'éditeur ne le lit pas).",
 	"cursor.rules": "les hooks de Cursor refusent ce que le produit refuse (push sur la branche principale, force push, suppression en masse, écriture des fichiers protégés du produit, lancement d'un autre agent Cursor) et demandent pour une commande qu'une règle demande (`ask`), dans l'éditeur et dans la ligne de commande quand elle envoie le hook. Ils ne demandent pas avant l'écriture d'un fichier ni avant un accès au web (`preToolUse` ignore `ask`) : une règle qui demande d'abord pour une modification de fichier (`edit_code: ask`) ou pour le web (`internet: ask`) n'est pas demandée par Cursor, donc avant une telle action l'agent te demande dans le chat ; `internet: deny` et `edit_code: deny` sont refusés. Les outils de Cursor qui lisent un fichier ne passent pas par un hook : `.cursorignore` garde les secrets (`.env` et ses semblables) hors de portée de l'agent, et une commande qui en lit un est refusée. Le texte saisi dans une console déjà ouverte n'est pas vu non plus. Les hooks ne tournent que dans un dossier auquel tu fais confiance.",
 	"cursor.rules.hooks-kept": CURSOR_HOOKS_KEPT_FR,
@@ -9398,20 +9479,18 @@ const FALLBACK_REASONS = { fr: {
 	"cursor.installs.hooks-kept": CURSOR_HOOKS_KEPT_FR,
 	"cursor.decisions": "Cursor range les formulaires qu'un serveur MCP demande (« elicitation ») parmi ce qu'il sait faire, mais des rapports de son propre forum (Windows 11, Cursor 3.10.20, le 2026-07-07, encore vus sur 3.17.8) montrent le formulaire non affiché et l'appel d'outil qui reste en attente, et aucun n'a été vu affiché dans une session de ce produit (Cursor 3.23.12, le 2026-10-07) : les décisions te sont posées en texte dans le chat (« a, b ou c ? »), et l'agent enregistre ta réponse avec `chat.answer`, en la citant. Le moteur essaie quand même le formulaire d'abord (`chat.ask`) ; dans Cursor il attend 90 secondes un premier signe de vie, et sans rien il pose la question dans le chat pour le reste de la session. Un formulaire déjà répondu une fois est attendu aussi longtemps que dans n'importe quel autre outil.",
 	"cursor.usage": "Cursor ne garde aucun nombre de jetons nulle part sur la machine : ses transcriptions (`~/.cursor/projects/<projet>/agent-transcripts/`) contiennent les messages et les appels d'outils, sans jetons, sans modèle et sans date par ligne. Le moteur ne mesure donc rien d'une session Cursor (`measure.usage` répond `available: false`) et ne l'estime jamais ; la page d'usage de Cursor (le tableau de bord de ton compte) est la seule source. Le hook `stop` de l'éditeur porte peut-être des jetons (vu dans le code de Cursor lui-même, non vérifié rempli) : il n'est pas utilisé.",
+	"*.budget": "cet outil n'a pas de hook qui voit chaque appel d'outil avant qu'il parte : le moteur ne peut pas arrêter le travail au plafond d'une story au plus proche, ni tenir la pause de l'équipe pendant qu'un agent écrit. Le coût est lu après coup (là où le moteur sait lire les traces de l'outil) et le point de contrôle de budget s'ouvre alors.",
 	"*.usage": "le moteur ne lit aucune trace de cet outil : il ne mesure rien de ses sessions (`measure.usage` répond `available: false`) et ne l'estime jamais.",
 	"codex.mcp.config-kept": "sync n'a pas pu écrire `.codex/config.toml` (le fichier est à toi) : le serveur MCP `agentplugged` n'est pas déclaré pour Codex. Ajoute toi-même `[mcp_servers.agentplugged]` avec `command = \"npx\"` et `args = [\"-y\", \"agentplugged@<engine_version>\", \"mcp\"]`.",
-	"gemini-cli.mcp": "sync ne déclare le serveur MCP `agentplugged` dans `.gemini/settings.json` que si ce fichier existe déjà (sync ne crée jamais les réglages de Gemini CLI) : sinon, les anciennes installations de Gemini CLI ne voient pas le serveur.",
 	"*.mcp.conflict": "`{path}` déclare déjà un serveur MCP `agentplugged` qui n'est pas celui qu'écrit sync : il est laissé tel quel. Vérifie qu'il lance `npx -y agentplugged@<engine_version> mcp`.",
 	...Object.fromEntries([
 		"claude-code",
 		"codex",
 		"antigravity",
-		"gemini-cli",
 		"cursor"
 	].map((client) => [`${client}.model`, MODEL_INHERIT_FR])),
 	"codex.rules": "les hooks de Codex répondent `allow` ou `deny`, jamais `ask` : une règle de permission qui demande d'abord (`ask`, que toi seul poses) est écrite en règle `prompt` dans `.codex/rules/agentplugged.rules` seulement tant que Codex demande des approbations (niveau `strict`, modifications qui demandent d'abord) : sans approbation (par défaut, écrite en forme granulaire qui laisse quand même passer les formulaires), Codex ne peut pas demander, rien n'est écrit, et le hook laisse l'appel passer. Avant une telle action, l'agent te demande dans le chat. Ce que le produit refuse (push sur la branche principale, force push, suppression en masse, lecture de secrets, écriture de ses fichiers protégés) est refusé par le hook et, pour les commandes, par les règles propres à Codex. `internet: ask` désactive la recherche web et garde le bac à sable hors ligne ; `edit_code: ask` ou `deny` donne un bac à sable en lecture seule avec approbation sur demande. Les hooks ne tournent qu'une fois que tu les as approuvés (`/hooks` dans Codex, une seule fois).",
 	"codex.rules.config-kept": "sync n'a pas pu écrire `.codex/config.toml` (le fichier est à toi) : aucun hook n'applique les règles de permission pour Codex ; seules les règles de commandes de `.codex/rules/agentplugged.rules` le font.",
-	"gemini-cli.rules": "agentplugged ne génère aucun fichier de permissions pour Gemini CLI : les règles de permission de la constitution ne sont pas appliquées techniquement. Rien n'empêche un agent de modifier `.agentplugged/method.yaml` ou de lancer `npx agentplugged sync`, `rules set` ou `migrate` dans cet outil : les changements de règles passent par toi.",
 	"*.chat_proof": "agentplugged n'écrit pour cet outil aucun hook qui retienne tes messages : une réponse que tu donnes dans le chat est enregistrée « non vérifiée » (`chat_unverified`) et affichée ainsi partout, quel que soit le point (le journal garde la trace de chaque réponse). Pour que chaque réponse soit vérifiée, travaille dans Claude Code ; pour que les points à risque élevé passent par ta clé, choisis le niveau `strict`.",
 	"*.isolation": "les fichiers d'agents de cet outil ne savent pas lancer un développeur dans une copie de travail à lui : chaque développeur travaille seulement dans le `workdir` que renvoie `story.start`, la copie de travail propre à la story, une par story.",
 	...Object.fromEntries([
@@ -9430,7 +9509,7 @@ const FALLBACK_REASONS = { fr: {
 //#endregion
 //#region ../../packages/i18n/dist/catalogs/fr.js
 const fr = {
-	"cli.usage": "Utilisation : agentplugged <commande> [options]\n\nDepuis le chat : demande à ton agent, à l'écrit ou en dictée, ce qui t'est réservé (« passe la CI de la story 4-3, le runner est en panne ») :\n  il ouvre une demande, tu la valides dans le chat, et le moteur l'exécute. Les commandes ci-dessous existent aussi, pour qui préfère la ligne de commande ; seul le niveau strict les exige.\n\nCommandes :\n  init      Installe la méthode dans le dossier courant\n  profile   Choisit ce que fait la méthode pour ce produit (ou dans le chat)\n  doctor [--json] [--error <message>] [--exit-code <n>] [--report]  Regarde ta machine (Node, Git, la forge, tes outils IA, le trousseau…), dit ce qui manque et le répare avec ton accord ; code de sortie 1 si un point bloquant demeure\n  sync      Génère les fichiers des outils IA (Claude Code, Codex, Antigravity CLI, Cursor) à partir de la méthode\n  agent     Gère tes agents et compétences (ou dans le chat) :\n              agent create <id>    crée un agent (ou une compétence avec --skill)\n              agent edit <id>      indique les fichiers à modifier (crée le fichier de personnalisation d'un agent ou d'une compétence livrés)\n              agent edit <skill> --personal\n                                   ta couche à toi d'une compétence livrée, ignorée par Git\n              agent edit <id> --tier <niveau> --tool <outil>\n                                   choisit le niveau de modèle et l'outil IA préféré de l'agent\n              agent enable <id>    active un agent ou une compétence\n              agent disable <id>   désactive un agent ou une compétence\n  journal sync  Récupère le journal du dépôt distant, puis lui envoie les événements qui lui manquent (sans jamais forcer)\n  journal status  Affiche l'état du produit calculé à partir du journal : événements appliqués, ignorés, avertissements\n                  (.agentplugged/.cache/state.json ; son computed_at est la date du dernier événement appliqué, dans l'ordre de projection)\n  docs check  Vérifie les documents de .agentplugged/docs, epics et stories : leurs en-têtes, les stories (contrat, couverture du PRD, dépendances, intentions validées), et qu'aucun identifiant d'exigence n'a été renuméroté, réutilisé ou supprimé depuis la base (code de sortie 1 si des problèmes sont trouvés, 2 si la vérification n'a pas pu se faire)\n  mcp       Lance le serveur MCP par lequel les agents rendent compte, en stdio : un lanceur stable qui passe à un moteur plus récent entre deux appels, sans reconnexion (sync le déclare dans chaque outil IA)\n  update [--check on|off] [--auto on|off]  Installe le dernier moteur dans son propre dossier et met le produit dessus (ce que fait un oui à Noah ; dans un terminal interactif seulement) ; --check on|off : interroger le registre npm pour savoir si une version est sortie, au plus deux fois par jour (activé par défaut) ; --auto on|off : l'installer sans question (désactivé par défaut)\n  hook antigravity|codex pre-tool|post-tool  Les hooks du plugin d'Antigravity CLI et du projet de Codex, lancés par l'outil : les règles de permission avant un outil, les lectures de contenu extérieur après (sync les écrit)\n  publication <G-id> [--file <chemin>] [--raw]  Affiche le texte complet d'un livrable de lancement, de marketing ou de vente, la version qu'on t'a montrée (un seul fichier avec --file ; --raw : le fichier entier, en-tête compris)\n  publication export <G-id> [--force] [--unverified]  Écrit un livrable que tu as validé, prêt à publier, dans .agentplugged/exports/<G-id>/ (rien n'est publié, envoyé ni payé)\n  review [<G-id>]  Réponds à un point de contrôle ouvert, signé par ta clé, ou rouvre un point appliqué automatiquement (dans un terminal interactif seulement)\n  key presence [--reset]  Protège tes validations avec Windows Hello (--reset : recrée l'identifiant quand il ne marche plus)\n  key endorse [<human:…>]  Liste les clés de créateur en attente d'approbation, ou approuve une clé dont tu es sûr\n  key export [--out <fichier>]  Exporte la clé du produit, chiffrée par une phrase de passe, pour une autre machine\n  key import [--in <fichier>]  Importe la clé du produit exportée sur une autre machine (tapée, non affichée, sans --in)\n  key seal  Chiffre les fichiers de la Salle et de la mémoire encore en clair\n  trust dismiss  Écarte l'événement qui bloque les ordres quand le journal contient une autre racine de confiance que celle épinglée sur cette machine (rien à faire sinon)\n                   (review, key et trust : dans un terminal interactif seulement)\n  history   Affiche tes validations, de la plus récente à la plus ancienne (--story <e-s>, --since <date ISO>, --decision <décision> ;\n            --all : aussi les réponses ignorées par le journal, avec leur raison)\n  history --export <fichier.json|fichier.csv> [--force]  Les écrit dans un fichier (JSON ou CSV, selon son extension)\n  rules [show]  Affiche les règles de permission : ce que les agents font seuls (allow), après t'avoir demandé (ask) ou jamais (deny), lues sur la branche principale\n  rules set <action> <allow|ask|deny>  Change une règle ; rules reset : revient aux défauts (dans un terminal interactif seulement)\n  next      Affiche la prochaine étape en trois lignes : l'étape en cours, l'agent à appeler et où, et ce qui attend ta validation,\n            puis une quatrième ligne avec la commande à lancer quand l'étape en a une\n  migrate [--check]  Passe .agentplugged/ au format de ce moteur et l'épingle, avec une trace dans le journal (dans un terminal interactif seulement ; --check : montre ce qu'il ferait, sans rien écrire)\n  deferred [list] [<e-s>] [--all] [--json]  Affiche le travail reporté ouvert (les points qui verrouillent cette story ; --all : aussi les points fermés)\n  deferred show <D-id> [--json]  Affiche un point reporté\n  deferred resolve|drop <D-id> <raison>  Marque un point reporté traité, ou l'abandonne (ou dans le chat ; au terminal : interactif seulement)\n  story start <e-s>  Démarre une story : sa branche feat/<e-s>-<slug>, sa copie de travail à côté du dépôt et le hook de commit (pour toi ou un agent)\n  story pr <e-s>  Livre une story : pousse sa branche (jamais la principale) et ouvre ou met à jour sa pull request au modèle fixe, par gh ou glab déjà connecté\n  story ci <e-s> [--forge github|gitlab]  Lit la CI de la pull request ouverte d'une story (gh ou glab) ; en échec, la story repasse en développement\n  story ci <e-s> --waive \"<raison>\"  Accepte une story dont la CI ne peut pas être lue, pour le commit actuel de sa branche (ou dans le chat ; au terminal : interactif seulement)\n  ci setup [--forge github|gitlab]  Écrit la CI de base du produit (lint, tests, build, audit des dépendances), jamais par-dessus une CI existante\n  tests setup [--runner <nom>] [--e2e <nom>|none]  Prépare le cadre de test du produit d'après ses fichiers et propose, dans .agentplugged/proofs.yaml, la commande qui lance les tests d'un critère (jamais par-dessus une déclaration existante)\n  trace [<EF-n>] [--json]  Affiche la traçabilité : chaque exigence et son statut (à faire, en développement, en revue, livrée, en écart), ou une exigence avec ses stories, tests, pull requests et écarts\n  trace resolve <V-id> <raison>  Lève un écart (ou dans le chat ; au terminal : interactif seulement)\n  usage [--by story|step|skill|agent|session] [--story <e-s>] [--since <jour>] [--until <jour>] [--session <outil>:<id>] [--json]  Montre ce que tes outils d'IA ont consommé : des jetons et l'origine de chaque chiffre (nommé par l'outil, déduit du journal, ou inconnu), la part que rien n'a permis d'attribuer, les outils qu'on ne peut pas mesurer ; aucun montant, seulement l'estimation d'une story\n  eval check [<compétence>]  Vérifie les cas de comportement d'une compétence (valides, appelée d'après les mots de sa description, passage gardé) : gratuit, sans agent\n  eval init <compétence>  Propose des cas pour démarrer, écrits une fois, jamais par-dessus un fichier existant\n  eval run <compétence> [--mode quality|baseline|variant|trigger] [--runs <n>] [--record] [--plan]  Lance les cas avec un vrai agent dans un dossier propre (cela consomme des jetons : le plan vient d'abord ; jamais dans les tests), les note, compte les jetons et compare au passage gardé : un cas qui ne passe plus, ou un coût au-dessus du seuil, donne le code de sortie 1\n  pair [--no-open] [--nouveau] [--changer-de-compte]  Relie ton application web à ce produit : affiche un lien à cliquer, rien d'autre à faire (c'est le pont qui s'en charge, une fois installé)\n  bridge start|status  Lance le pont sur cette machine, ou dit son état. Le pont se distribue à part, sous la licence d'Innovel Studio SASU : cette commande ne fait que le lancer une fois installé\n\nOptions :\n  --profile <profil>   new-product, maintenance, launch-only ou prototype, sans questions\n  --validation <niveau> init, profile : comment tu réponds aux points de contrôle, chat (dans le chat de ton outil IA, par défaut), auto ou strict\n  --installs <mode>    init, profile : comment s'installent les dépendances, visible (sans validation, affichées dans l'activité et inscrites au journal, par défaut) ou validate (une validation chacune)\n  --points <liste>     init, profile : les points de validation qui t'attendent (framing, architecture, breakdown, merge, release, publication, séparés par des virgules ; none : aucun), les agents décident les autres\n  --workflow recommended  init, profile : garde le workflow Git recommandé pour tout (une branche par story, la CI sur la forge quand il y en a une, fusion par pull request, une revue avant la fusion)\n  --branches <modèle>  init, profile : les branches de base, main (seule), main+dev (les stories arrivent sur dev, une mise en production la fait passer dans main) ou <production>+<intégration>\n  --story-branches <yes|no>  init, profile : une branche par story, ou on travaille sur la branche où arrivent les stories\n  --ci <mode>          init, profile : la CI, none, local (ta machine) ou remote (la forge)\n  --merge <mode>       init, profile : comment une story est fusionnée, pr (une pull request) ou direct (par le moteur, jamais poussé)\n  --review <yes|no>    init, profile : une revue avant la fusion\n  --skill              agent create : crée une compétence plutôt qu'un agent\n  --name, --title, --description, --domain, --phase, --icon, --role <texte>\n                       agent create : réponses données sans questions (une compétence ne prend que --description)\n  --tier <niveau>      agent edit : niveau de modèle, reasoning, code, fast ou multimodal ; `--tier default` revient au niveau propre de l'agent\n  --tool <outil>       agent edit : outil IA préféré, claude-code, codex, antigravity ou cursor ; `--tool none` retire l'outil préféré\n  --remote <nom>       journal sync : le dépôt distant Git à utiliser (par défaut celui que suit la branche courante, sinon origin)\n  --recreate-remote    journal sync : envoie le journal local comme nouvelle branche distante, après la suppression voulue de l'ancienne\n  --base <réf>         docs check : la version Git avec laquelle comparer (HEAD par défaut)\n  --story <e-s>        history, usage : seulement cette story (par exemple 2-6)\n  --since <date>       history, usage : à partir de cette date : 2026-10-03 (minuit, heure locale), ou une date et une heure avec leur décalage, 2026-10-03T12:00:00Z ou 2026-10-03T14:00:00+02:00\n  --by <axe>            usage : story, step (par défaut), skill, agent ou session\n  --until <jour>        usage : jusqu'à ce jour (AAAA-MM-JJ, UTC), avec --since\n  --session <outil>:<id> usage : dit aussi ce qui a rendu cette session plus chère (compétences chargées deux fois, fichiers relus, outils en échec ; Claude Code seulement)\n  --decision <décision> history : approved, approved_with_reservations, rejected, changes_requested, option_chosen, waived ou reopened\n  --all                history : aussi les réponses ignorées par le journal, avec leur raison (dans l'export aussi)\n  --export <fichier>   history : écrit dans un fichier .json (exact) ou .csv (pour les tableurs), relatif au dossier courant\n  --force              history --export, publication export : remplace un fichier existant\n  --file <chemin>      publication : n'affiche que ce fichier du livrable\n  --unverified         publication export : exporte aussi une approbation donnée dans le chat sans preuve (outil sans hook)\n  --raw                publication : le fichier entier, avec l'en-tête YAML de la base de connaissance\n  --error <message>    doctor : le message de la commande qui a échoué (`--error=<message>` s'il commence par un tiret ; `-` : lu sur l'entrée standard, redirigée) ; le moteur dit ce qu'il constate sur ta machine, à part de ce qu'il suppose\n  --exit-code <n>      doctor : le code de sortie de la commande qui a échoué (137, 127…)\n  --report             doctor : le rapport à joindre à une demande d'aide (système, versions, résultat de chaque vérification), sans nom d'utilisateur, chemin personnel, jeton ni contenu de ton produit ; il ne répare rien\n  --json               next, deferred, trace, usage, doctor : la réponse en JSON, pour les scripts (une erreur aussi, sur la sortie standard, sauf doctor)\n  --yes, -y            init : ne demande rien, prend les réponses recommandées (et écrit les fichiers des outils IA) ; dans un script, le code de sortie dit si un point bloquant demeure\n  --tools <liste>      init : les outils IA à brancher, parmi claude-code, codex, antigravity et cursor, séparés par des virgules (par défaut ceux qui sont trouvés, sinon tous)\n  --permissions <mode> init, profile : protected (par défaut : ton outil IA continue de demander avant les gestes sensibles) ou free (son mode sans questions reste possible)\n  --channel <boutique>  init : la boutique où la méthode a été trouvée (claude-plugin), écrite par la compétence d'accueil du plugin Claude Code pour que `doctor` dise comment la méthode a été installée\n  --no-sync            init : n'écrit pas les fichiers des outils IA\n  --out <fichier>      key export : écrit la clé exportée dans ce nouveau fichier, hors du dépôt\n  --in <fichier>       key import : lit la clé exportée dans ce fichier\n  --check              migrate : montre ce qu'il ferait, sans rien écrire\n  --forge <forge>      ci setup, story ci : github ou gitlab (par défaut, ci.forge de method.yaml, sinon la forge du dépôt distant origin)\n  --runner <nom>       tests setup : le lanceur de tests unitaires et d'API (vitest, jest, mocha, node-test, pytest, go-test, cargo-test, rspec, phpunit, dotnet-test, maven, gradle)\n  --e2e <nom>          tests setup : le lanceur de bout en bout (playwright, cypress) ou none\n  --waive <raison>     story ci : accepte la story sans sa CI, pour le commit actuel de sa branche\n  --upgrade-engine     init : épingle la version du moteur en cours dans `.agentplugged/method.yaml` et rafraîchit la méthode (sans trace dans le journal : pour changer seulement de moteur, préfère `migrate`)\n  --engine-any         s'exécute même si `.agentplugged/method.yaml` épingle une autre version du moteur (avec un avertissement)\n  --version, -v        affiche la version d'agentplugged\n  --help, -h           affiche cette aide",
+	"cli.usage": "Utilisation : agentplugged <commande> [options]\n\nDepuis le chat : demande à ton agent, à l'écrit ou en dictée, ce qui t'est réservé (« passe la CI de la story 4-3, le runner est en panne ») :\n  il ouvre une demande, tu la valides dans le chat, et le moteur l'exécute. Les commandes ci-dessous existent aussi, pour qui préfère la ligne de commande ; seul le niveau strict les exige.\n\nCommandes :\n  init      Installe la méthode dans le dossier courant\n  profile   Choisit ce que fait la méthode pour ce produit (ou dans le chat)\n  doctor [--json] [--error <message>] [--exit-code <n>] [--report]  Regarde ta machine (Node, Git, la forge, tes outils IA, le trousseau…), dit ce qui manque et le répare avec ton accord ; code de sortie 1 si un point bloquant demeure\n  sync      Génère les fichiers des outils IA (Claude Code, Codex, Antigravity CLI, Cursor) à partir de la méthode\n  agent     Gère tes agents et compétences (ou dans le chat) :\n              agent create <id>    crée un agent (ou une compétence avec --skill)\n              agent edit <id>      indique les fichiers à modifier (crée le fichier de personnalisation d'un agent ou d'une compétence livrés)\n              agent edit <skill> --personal\n                                   ta couche à toi d'une compétence livrée, ignorée par Git\n              agent edit <id> --tier <niveau> --tool <outil>\n                                   choisit le niveau de modèle et l'outil IA préféré de l'agent\n              agent enable <id>    active un agent ou une compétence\n              agent disable <id>   désactive un agent ou une compétence\n  journal sync  Récupère le journal du dépôt distant, puis lui envoie les événements qui lui manquent (sans jamais forcer)\n  journal status  Affiche l'état du produit calculé à partir du journal : événements appliqués, ignorés, avertissements\n                  (.agentplugged/.cache/state.json ; son computed_at est la date du dernier événement appliqué, dans l'ordre de projection)\n  docs check  Vérifie les documents de .agentplugged/docs, epics et stories : leurs en-têtes, les stories (contrat, couverture du PRD, dépendances, intentions validées), et qu'aucun identifiant d'exigence n'a été renuméroté, réutilisé ou supprimé depuis la base (code de sortie 1 si des problèmes sont trouvés, 2 si la vérification n'a pas pu se faire)\n  mcp       Lance le serveur MCP par lequel les agents rendent compte, en stdio : un lanceur stable qui passe à un moteur plus récent entre deux appels, sans reconnexion (sync le déclare dans chaque outil IA)\n  update [--check on|off] [--auto on|off]  Installe le dernier moteur dans son propre dossier et met le produit dessus (ce que fait un oui à Noah ; dans un terminal interactif seulement) ; --check on|off : interroger le registre npm pour savoir si une version est sortie, au plus deux fois par jour (activé par défaut) ; --auto on|off : l'installer sans question (désactivé par défaut)\n  hook antigravity|codex pre-tool|post-tool  Les hooks du plugin d'Antigravity CLI et du projet de Codex, lancés par l'outil : les règles de permission avant un outil, les lectures de contenu extérieur après (sync les écrit)\n  publication <G-id> [--file <chemin>] [--raw]  Affiche le texte complet d'un livrable de lancement, de marketing ou de vente, la version qu'on t'a montrée (un seul fichier avec --file ; --raw : le fichier entier, en-tête compris)\n  publication export <G-id> [--force] [--unverified]  Écrit un livrable que tu as validé, prêt à publier, dans .agentplugged/exports/<G-id>/ (rien n'est publié, envoyé ni payé)\n  review [<G-id>]  Réponds à un point de contrôle ouvert, signé par ta clé, ou rouvre un point appliqué automatiquement (dans un terminal interactif seulement)\n  key presence [--reset]  Protège tes validations avec Windows Hello (--reset : recrée l'identifiant quand il ne marche plus)\n  key endorse [<human:…>]  Liste les clés de créateur en attente d'approbation, ou approuve une clé dont tu es sûr\n  key export [--out <fichier>]  Exporte la clé du produit, chiffrée par une phrase de passe, pour une autre machine\n  key import [--in <fichier>]  Importe la clé du produit exportée sur une autre machine (tapée, non affichée, sans --in)\n  key seal  Chiffre les fichiers de la Salle et de la mémoire encore en clair\n  trust dismiss  Écarte l'événement qui bloque les ordres quand le journal contient une autre racine de confiance que celle épinglée sur cette machine (rien à faire sinon)\n                   (review, key et trust : dans un terminal interactif seulement)\n  history   Affiche tes validations, de la plus récente à la plus ancienne (--story <e-s>, --since <date ISO>, --decision <décision> ;\n            --all : aussi les réponses ignorées par le journal, avec leur raison)\n  history --export <fichier.json|fichier.csv> [--force]  Les écrit dans un fichier (JSON ou CSV, selon son extension)\n  rules [show]  Affiche les règles de permission : ce que les agents font seuls (allow), après t'avoir demandé (ask) ou jamais (deny), lues sur la branche principale\n  rules set <action> <allow|ask|deny>  Change une règle ; rules reset : revient aux défauts (dans un terminal interactif seulement)\n  next      Affiche la prochaine étape en trois lignes : l'étape en cours, l'agent à appeler et où, et ce qui attend ta validation,\n            puis une quatrième ligne avec la commande à lancer quand l'étape en a une\n  migrate [--check]  Passe .agentplugged/ au format de ce moteur et l'épingle, avec une trace dans le journal (dans un terminal interactif seulement ; --check : montre ce qu'il ferait, sans rien écrire)\n  deferred [list] [<e-s>] [--all] [--json]  Affiche le travail reporté ouvert (les points qui verrouillent cette story ; --all : aussi les points fermés)\n  deferred show <D-id> [--json]  Affiche un point reporté\n  deferred resolve|drop <D-id> <raison>  Marque un point reporté traité, ou l'abandonne (ou dans le chat ; au terminal : interactif seulement)\n  story start <e-s>  Démarre une story : sa branche feat/<e-s>-<slug>, sa copie de travail à côté du dépôt et le hook de commit (pour toi ou un agent)\n  story pr <e-s>  Livre une story : pousse sa branche (jamais la principale) et ouvre ou met à jour sa pull request au modèle fixe, par gh ou glab déjà connecté\n  story ci <e-s> [--forge github|gitlab]  Lit la CI de la pull request ouverte d'une story (gh ou glab) ; en échec, la story repasse en développement\n  story ci <e-s> --waive \"<raison>\"  Accepte une story dont la CI ne peut pas être lue, pour le commit actuel de sa branche (ou dans le chat ; au terminal : interactif seulement)\n  ci setup [--forge github|gitlab]  Écrit la CI de base du produit (lint, tests, build, audit des dépendances), jamais par-dessus une CI existante\n  tests setup [--runner <nom>] [--e2e <nom>|none]  Prépare le cadre de test du produit d'après ses fichiers et propose, dans .agentplugged/proofs.yaml, la commande qui lance les tests d'un critère (jamais par-dessus une déclaration existante)\n  trace [<EF-n>] [--json]  Affiche la traçabilité : chaque exigence et son statut (à faire, en développement, en revue, livrée, en écart), ou une exigence avec ses stories, tests, pull requests et écarts\n  trace resolve <V-id> <raison>  Lève un écart (ou dans le chat ; au terminal : interactif seulement)\n  usage [--by story|step|skill|agent|session] [--story <e-s>] [--since <jour>] [--until <jour>] [--session <outil>:<id>] [--json]  Montre ce que tes outils d'IA ont consommé : des jetons et l'origine de chaque chiffre (nommé par l'outil, déduit du journal, ou inconnu), la part que rien n'a permis d'attribuer, les outils qu'on ne peut pas mesurer ; aucun montant, seulement l'estimation d'une story\n  eval check [<compétence>]  Vérifie les cas de comportement d'une compétence (valides, appelée d'après les mots de sa description, passage gardé) : gratuit, sans agent\n  eval init <compétence>  Propose des cas pour démarrer, écrits une fois, jamais par-dessus un fichier existant\n  eval run <compétence> [--mode quality|baseline|variant|trigger] [--runs <n>] [--record] [--plan]  Lance les cas avec un vrai agent dans un dossier propre (cela consomme des jetons : le plan vient d'abord ; jamais dans les tests), les note, compte les jetons et compare au passage gardé : un cas qui ne passe plus, ou un coût au-dessus du seuil, donne le code de sortie 1\n  pair [--no-open] [--nouveau] [--changer-de-compte]  Relie ton application web à ce produit : affiche un lien à cliquer, rien d'autre à faire (c'est le pont qui s'en charge, une fois installé)\n  device list|revoke <appareil>  Liste les appareils reliés à ce produit, ou en retire un : il ne reçoit plus rien et peut être relié de nouveau (c'est le pont qui s'en charge, une fois installé)\n  bridge install|uninstall|start|status  Installe le pont (et le met à jour) comme service de ton compte, le retire, le lance sur cette machine, ou dit son état. Le pont se distribue à part, sous la licence d'Innovel Studio SASU : cette commande ne fait que l'installer et le lancer\n\nOptions :\n  --profile <profil>   new-product, maintenance, launch-only ou prototype, sans questions\n  --validation <niveau> init, profile : comment tu réponds aux points de contrôle, chat (dans le chat de ton outil IA, par défaut), auto ou strict\n  --installs <mode>    init, profile : comment s'installent les dépendances, visible (sans validation, affichées dans l'activité et inscrites au journal, par défaut) ou validate (une validation chacune)\n  --points <liste>     init, profile : les points de validation qui t'attendent (framing, architecture, breakdown, merge, release, publication, séparés par des virgules ; none : aucun), les agents décident les autres\n  --workflow recommended  init, profile : garde le workflow Git recommandé pour tout (une branche par story, la CI sur la forge quand il y en a une, fusion par pull request, une revue avant la fusion)\n  --branches <modèle>  init, profile : les branches de base, main (seule), main+dev (les stories arrivent sur dev, une mise en production la fait passer dans main) ou <production>+<intégration>\n  --story-branches <yes|no>  init, profile : une branche par story, ou on travaille sur la branche où arrivent les stories\n  --ci <mode>          init, profile : la CI, none, local (ta machine) ou remote (la forge)\n  --merge <mode>       init, profile : comment une story est fusionnée, pr (une pull request) ou direct (par le moteur, jamais poussé)\n  --review <yes|no>    init, profile : une revue avant la fusion\n  --skill              agent create : crée une compétence plutôt qu'un agent\n  --name, --title, --description, --domain, --phase, --icon, --role <texte>\n                       agent create : réponses données sans questions (une compétence ne prend que --description)\n  --tier <niveau>      agent edit : niveau de modèle, reasoning, code, fast ou multimodal ; `--tier default` revient au niveau propre de l'agent\n  --tool <outil>       agent edit : outil IA préféré, claude-code, codex, antigravity ou cursor ; `--tool none` retire l'outil préféré\n  --remote <nom>       journal sync : le dépôt distant Git à utiliser (par défaut celui que suit la branche courante, sinon origin)\n  --recreate-remote    journal sync : envoie le journal local comme nouvelle branche distante, après la suppression voulue de l'ancienne\n  --base <réf>         docs check : la version Git avec laquelle comparer (HEAD par défaut)\n  --story <e-s>        history, usage : seulement cette story (par exemple 2-6)\n  --since <date>       history, usage : à partir de cette date : 2026-10-03 (minuit, heure locale), ou une date et une heure avec leur décalage, 2026-10-03T12:00:00Z ou 2026-10-03T14:00:00+02:00\n  --by <axe>            usage : story, step (par défaut), skill, agent ou session\n  --until <jour>        usage : jusqu'à ce jour (AAAA-MM-JJ, UTC), avec --since\n  --session <outil>:<id> usage : dit aussi ce qui a rendu cette session plus chère (compétences chargées deux fois, fichiers relus, outils en échec ; Claude Code seulement)\n  --decision <décision> history : approved, approved_with_reservations, rejected, changes_requested, option_chosen, waived ou reopened\n  --all                history : aussi les réponses ignorées par le journal, avec leur raison (dans l'export aussi)\n  --export <fichier>   history : écrit dans un fichier .json (exact) ou .csv (pour les tableurs), relatif au dossier courant\n  --force              history --export, publication export : remplace un fichier existant\n  --file <chemin>      publication : n'affiche que ce fichier du livrable\n  --unverified         publication export : exporte aussi une approbation donnée dans le chat sans preuve (outil sans hook)\n  --raw                publication : le fichier entier, avec l'en-tête YAML de la base de connaissance\n  --error <message>    doctor : le message de la commande qui a échoué (`--error=<message>` s'il commence par un tiret ; `-` : lu sur l'entrée standard, redirigée) ; le moteur dit ce qu'il constate sur ta machine, à part de ce qu'il suppose\n  --exit-code <n>      doctor : le code de sortie de la commande qui a échoué (137, 127…)\n  --report             doctor : le rapport à joindre à une demande d'aide (système, versions, résultat de chaque vérification), sans nom d'utilisateur, chemin personnel, jeton ni contenu de ton produit ; il ne répare rien\n  --json               next, deferred, trace, usage, doctor : la réponse en JSON, pour les scripts (une erreur aussi, sur la sortie standard, sauf doctor)\n  --yes, -y            init : ne demande rien, prend les réponses recommandées (et écrit les fichiers des outils IA) ; dans un script, le code de sortie dit si un point bloquant demeure\n  --tools <liste>      init : les outils IA à brancher, parmi claude-code, codex, antigravity et cursor, séparés par des virgules (par défaut ceux qui sont trouvés, sinon tous)\n  --permissions <mode> init, profile : protected (par défaut : ton outil IA continue de demander avant les gestes sensibles) ou free (son mode sans questions reste possible)\n  --channel <boutique>  init : la boutique où la méthode a été trouvée (claude-plugin), écrite par la compétence d'accueil du plugin Claude Code pour que `doctor` dise comment la méthode a été installée\n  --no-sync            init : n'écrit pas les fichiers des outils IA\n  --clean-gemini       sync : retire seulement les fichiers qu'AgentPlugged a écrits pour Gemini CLI (arrêté) et liste les autres (avec --yes : les retire aussi)\n  --out <fichier>      key export : écrit la clé exportée dans ce nouveau fichier, hors du dépôt\n  --in <fichier>       key import : lit la clé exportée dans ce fichier\n  --check              migrate : montre ce qu'il ferait, sans rien écrire\n  --forge <forge>      ci setup, story ci : github ou gitlab (par défaut, ci.forge de method.yaml, sinon la forge du dépôt distant origin)\n  --runner <nom>       tests setup : le lanceur de tests unitaires et d'API (vitest, jest, mocha, node-test, pytest, go-test, cargo-test, rspec, phpunit, dotnet-test, maven, gradle)\n  --e2e <nom>          tests setup : le lanceur de bout en bout (playwright, cypress) ou none\n  --waive <raison>     story ci : accepte la story sans sa CI, pour le commit actuel de sa branche\n  --upgrade-engine     init : épingle la version du moteur en cours dans `.agentplugged/method.yaml` et rafraîchit la méthode (sans trace dans le journal : pour changer seulement de moteur, préfère `migrate`)\n  --engine-any         s'exécute même si `.agentplugged/method.yaml` épingle une autre version du moteur (avec un avertissement)\n  --version, -v        affiche la version d'agentplugged\n  --help, -h           affiche cette aide",
 	"cli.error": "Erreur {code} : {message}",
 	"init.summary.title": "Méthode installée dans {root}",
 	"init.action.created": "créé",
@@ -9469,6 +9548,10 @@ const fr = {
 	"sync.warning.overwritten": "{path} : modification manuelle écrasée.",
 	"sync.warning.conflict": "{path} : sans marque agentplugged (un en-tête, ou la description générée d'un plugin), il t'appartient et a été laissé tel quel. Renomme-le ou supprime-le pour que sync le génère.",
 	"sync.warning.kept": "{path} : n'est plus généré, mais son en-tête a été retiré : il t'appartient et a été conservé.",
+	"sync.warning.gemini_legacy": "Gemini CLI n'est plus pris en charge par Google ; AgentPlugged utilise maintenant Antigravity CLI. Tes anciens fichiers de Gemini CLI ({path}) sont encore lus et laissés tels quels : rien n'y est écrit ni supprimé. Pour retirer seulement les fichiers qu'AgentPlugged a écrits, lance `npx agentplugged sync --clean-gemini`.",
+	"sync.warning.gemini_unproven": "{path} : AgentPlugged ne peut pas prouver qu'il l'a écrit tel quel (modifié depuis, ou sans trace), il a donc été conservé.",
+	"sync.gemini.confirm": "Les fichiers ci-dessus ont été conservés. Pour les retirer aussi, vérifie-les, puis lance `npx agentplugged sync --clean-gemini --yes`.",
+	"sync.gemini.nothing": "Rien à nettoyer : aucun fichier écrit par AgentPlugged pour Gemini CLI n'a été trouvé.",
 	"tools.title": "Outils IA",
 	"tools.line": "{name} {version} — {sources}",
 	"tools.line.unknown_version": "{name} (version non reconnue) — {sources}",
@@ -9897,7 +9980,7 @@ const fr = {
 	"history.author.root": "{device} (clé racine)",
 	"history.author.endorsed": "{device} (approuvée le {date})",
 	"history.author.endorsed_undated": "{device} (approuvée)",
-	"history.source.terminal": "terminal",
+	"history.source.terminal": "au terminal",
 	"history.option": "option {option}",
 	"history.waiver_until": "jusqu'au {date}",
 	"history.assurance": "assurance {assurance}",
@@ -9964,6 +10047,10 @@ const fr = {
 	"key.export.hint": "Sur l'autre machine, lance `npx agentplugged key import` (ou `--in <fichier>`) et tape la même phrase de passe. Garde bien la phrase de passe : sans elle l'export ne sert à rien, et une clé du produit perdue rend le contenu chiffré illisible pour toujours.",
 	"key.import.done": "Clé du produit {key_id} importée dans le trousseau de cette machine.",
 	"key.import.already": "Cette machine a déjà la clé du produit {key_id}.",
+	"key.export.many": "Cet export contient {count} clés : la clé actuelle et celles gardées d'avant chaque renouvellement, pour que tout l'historique reste lisible là où tu l'importes.",
+	"key.export.missing": "Attention : cette machine n'a pas {count} ancienne(s) clé(s) de ce produit ({key_ids}). Ce qu'elles ont écrit ne se lira pas depuis cet export ; exporte depuis une machine qui les a.",
+	"key.import.many": "Clés gardées sur cette machine : {key_ids}.",
+	"key.import.older": "Anciennes clés du produit importées : l'historique écrit avec elles est lisible. La clé actuelle {key_id} manque encore ici : importe un export fait après le dernier renouvellement, ou laisse le renouvellement parvenir à cette machine.",
 	"init.product_key.created": "Clé du produit créée ({key_id}) : les coûts, les notes de sécurité, la Salle et la mémoire sont chiffrés avec elle. Elle reste dans le trousseau de cette machine, jamais dans le dépôt.",
 	"init.product_key.ready": "Clé du produit : {key_id}.",
 	"init.product_key.published": "Son identifiant est annoncé dans le journal de ce produit.",
@@ -10180,6 +10267,7 @@ const fr = {
 	"next.step.knowledge_base": "Générer la base de connaissance",
 	"next.step.knowledge_base_review": "Base de connaissance en attente de ta relecture",
 	"next.step.knowledge_base_decision": "Réponds à Zoé sur la base de connaissance",
+	"next.step.paused": "L'équipe est en pause : reprends-la quand tu es prêt",
 	"reason.docSource": "une liste de { path, blob } : le chemin d'un document lu, et l'id du blob de la version lue (40 ou 64 caractères hexadécimaux minuscules)",
 	"docs.check.warning.kb_stale": "la page {path} de la base de connaissance s'appuie sur une autre version de {source} (blob {recorded}) que celle que tu as validée dans {checkpoint} (blob {blob}) : Zoé la met à jour.",
 	"docs.check.warning.kb_source_unrecorded": "la page {path} de la base de connaissance s'appuie sur {source}, que tu as validé dans {checkpoint} (blob {blob}), sans noter la version lue (`sources` dans son en-tête) : Zoé la met à jour.",
@@ -10250,6 +10338,7 @@ const fr = {
 	"error.story_not_startable.not_builder": "{agent} ne développe pas la story {story} : c'est à {owner} (son responsable, ou un agent de la capacité du sprint).",
 	"error.story_not_startable.started_by_other": "La story {story} a été démarrée par {agent} : une story n'a jamais deux développeurs, seul {agent} la reprend.",
 	"error.story_not_startable.parallel_limit": "La story {story} attend : {limit} stories sont déjà développées en même temps ({building}), le plafond du profil (max_parallel_stories). Démarre-la quand l'une d'elles sera terminée. Rien n'a été créé.",
+	"error.story_not_startable.team_paused": "L'équipe est en pause : la story {story} ne démarre pas tant que le créateur ne l'a pas reprise. Rien n'a été créé.",
 	"error.story_not_startable.unsupported_repository": "Ce dépôt ne peut pas accueillir la copie de travail d'une story ({why} : un dépôt nu, ou à la racine d'un disque). Rien n'a été créé.",
 	"error.story_not_startable.not_recorded": "La branche {branch} et la copie de travail {path} sont créées, mais rien n'est inscrit ({cause}) : relance la même commande.",
 	"error.journal_busy_replanned": "Le journal a changé pendant la vérification de {command} ({attempts} essais) : rien n'a été écrit. Réessaie dans un instant.",
@@ -10464,6 +10553,8 @@ const fr = {
 	"error.delegation_invalid.skill_autonomous": "La compétence {to} n'a pas de sous-agent : passe-la dans la conversation. Rien n'a été écrit.",
 	"error.delegation_invalid.story_required": "{to} est un développeur : il travaille sur une story, une instance par story. Donne la story. Rien n'a été écrit.",
 	"error.delegation_invalid.story_taken": "La story {story} est déjà développée par {agent} : une story n'a jamais deux développeurs. Rien n'a été écrit.",
+	"error.team_already_paused": "L'équipe est déjà en pause depuis {since} : il n'y a rien de plus à tenir. Rien n'a été écrit.",
+	"error.delegation_invalid.team_paused": "L'équipe est en pause : rien n'est confié à {to} tant que le créateur ne l'a pas reprise. Rien n'a été écrit.",
 	"error.delegation_invalid.parallel_limit": "Le plafond de {limit} stories en parallèle est atteint ({building}) : la story {story} attend qu'une d'elles soit terminée. Rien n'a été écrit.",
 	"checkpoint.type.creator_action": "action réservée",
 	"creator_action.kind.ci_waive": "accepter une story sans sa CI",
@@ -10989,9 +11080,29 @@ const fr = {
 	"error.relay.relay_connection_replaced": "Une connexion plus récente de cet appareil a pris la place de celle-ci.",
 	"error.relay.relay_prekey_invalid": "Le relais a refusé cette clé de réception. Rien n'a été gardé.",
 	"error.relay.relay_unavailable": "Le relais n'a pas pu le faire maintenant. Rien n'a été fait : réessaie.",
+	"error.relay.vault_refused": "Le relais n'a pas gardé le dernier état de ton projet. Ta machine le scelle de nouveau.",
+	"error.relay.push_refused": "Le relais n'a pas pris cette demande de notification. Rien n'a été envoyé.",
 	"error.relay.rendezvous_unknown": "Ce lien d'appairage n'existe plus. Relance la commande pour en obtenir un nouveau.",
 	"error.relay.rendezvous_refused": "Le relais n'a pas pu ouvrir ce point de rencontre. Réessaie dans un moment.",
 	"error.relay.rendezvous_attach_refused": "Le relais n'a pas pu rattacher cette machine à ton compte. Réessaie avec un nouveau lien.",
+	"error.relay.challenge_expired": "Cette étape a pris trop de temps. Recommence.",
+	"error.relay.challenge_reused": "Cette étape a déjà servi. Recommence.",
+	"error.relay.origin_mismatch": "Cette page n'a pas le droit d'utiliser ta clé d'accès avec AgentPlugged. Ouvre l'adresse officielle.",
+	"error.relay.credential_already_registered": "Cette clé d'accès appartient déjà à un compte. Connecte-toi avec elle.",
+	"error.relay.email_code_invalid": "Ce code n'est pas le bon. Vérifie le courriel et réessaie.",
+	"error.relay.email_code_expired": "Ce code n'est plus valable. Demande un nouveau code.",
+	"error.relay.email_already_registered": "Un compte existe déjà avec cette adresse. Connecte-toi avec ta clé d'accès.",
+	"error.relay.account_request_invalid": "La demande n'est pas valide. Vérifie ce que tu as saisi.",
+	"error.relay.account_sign_in_failed": "Cette clé d'accès n'a pas été reconnue. Réessaie, ou utilise un autre appareil.",
+	"error.relay.account_session_required": "Tu es déconnecté. Connecte-toi de nouveau.",
+	"error.relay.account_deleted": "Ce compte a été supprimé : cet appareil n'y est plus relié.",
+	"error.relay.export_not_ready": "Ton export est encore en préparation. Réessaie dans un instant.",
+	"error.relay.export_gone": "Cet export a déjà été téléchargé, ou son lien a expiré. Demande-en un nouveau.",
+	"error.relay.passkey_limit": "Tu as déjà le maximum de clés d'accès pour un compte. Retires-en une avant d'en ajouter une autre.",
+	"error.relay.passkey_last": "C'est ta dernière clé d'accès : sans elle, personne ne pourrait plus se connecter à ce compte. Ajoute-en une autre d'abord.",
+	"error.relay.share_limit": "Tu as déjà le maximum de liens de partage actifs. Retire-en un avant d'en créer un autre.",
+	"error.relay.share_too_large": "Cette page est trop volumineuse pour être partagée.",
+	"error.relay.share_unavailable": "Ce lien ne fonctionne pas : il a expiré ou a été retiré.",
 	"error.relay.upgrade_required": "Cet appareil parle une version du protocole que le relais n'accepte plus : mets-le à jour.",
 	"points.title": "Les points de validation : ceux que tu gardes pour toi. Tout le reste est décidé par l'agent responsable, avec sa raison au journal, et tu peux le rouvrir quand tu veux.",
 	"points.point.framing": "Documents de cadrage (brief, PRD, spécification UX) et la fin de leurs phases",
@@ -11004,10 +11115,15 @@ const fr = {
 	"points.summary": "Points qui t'attendent : {list}. Les agents décident les autres.",
 	"points.summary.none": "Aucun point ne t'attend : les agents décident tous les points.",
 	"history.source.agent": "décidé par l'agent responsable",
+	"history.source.web": "depuis la vue web",
+	"history.source.mobile": "depuis le téléphone",
 	"assurance.agent": "décision d'un agent (pas ta réponse), avec sa raison ; tu peux la rouvrir",
+	"assurance.device": "signé par un appareil que tu as relié (la vue web ou ton téléphone)",
 	"review.agent_decided": "Décidé par l'agent {agent} le {at} : {decision}. Raison : {reason}",
 	"next.step.point_decision": "Un point que tu ne gardes pas attend la décision de l'agent responsable",
 	"next.independent": "Le travail continue sans toi : cette étape ne dépend d'aucun des points qui t'attendent.",
+	"next.paused": "L'équipe est en pause depuis {since}. Chaque agent finit l'étape en cours et ne démarre rien de nouveau ; reprends-la depuis la vue web, le téléphone, ou en le demandant à Noah.",
+	"next.paused.stopped": "L'équipe a été arrêtée en urgence depuis {since} : les programmes lancés par le pont ont été coupés, et rien ne démarre tant que tu ne l'as pas reprise.",
 	"next.stop": "Rien d'indépendant ne reste : les points qui t'attendent bloquent la suite, les agents s'arrêtent là.",
 	"next.morning": "Depuis ta dernière validation : {done} story(ies) terminée(s), {decided} point(s) décidé(s) par les agents, {waiting} point(s) qui t'attendent.",
 	"docs.check.skipped": "Étape sautée (avertissement) : {path}:{line} : {code} : {message}",
@@ -11057,7 +11173,10 @@ const fr = {
 	"update.done_pinned": "Le moteur {version} est installé (le produit l'épinglait déjà). Tes sessions ouvertes passent dessus à leur prochain appel.",
 	"update.failed": "La mise à jour n'a pas eu lieu ({reason}). {message} Le moteur qui tourne n'a pas été touché.",
 	"error.engine_version_too_old.agent": "{path} épingle le moteur {pinned} et cette session tourne encore sur {engine_version} : rien n'a été écrit. Appelle `state.next` (ou `state.get`) : il porte `engine_update`, et le « oui » du créateur à guard.creator_action `engine_update` {install: true} installe {pinned} et fait passer cette session dessus à ton prochain appel. Dis-le au créateur en une phrase ; ne lui dis jamais de reconnecter ni de taper une commande.",
-	"bridge.launcher.not_installed": "Le pont n'est pas installé sur cette machine. Il se distribue à part, sous la licence d'Innovel Studio SASU : récupère-le sur https://agentplugged.ai. Le reste d'AgentPlugged (`state.next`, `review`, le serveur MCP) fonctionne sans lui.",
+	"bridge.launcher.not_installed": "Le pont n'est pas installé sur cette machine. Il se distribue à part, sous la licence d'Innovel Studio SASU : installe-le avec `agentplugged bridge install` (détails sur https://agentplugged.ai). Le reste d'AgentPlugged (`state.next`, `review`, le serveur MCP) fonctionne sans lui.",
+	"bridge.launcher.installing": "Récupération du pont (la version la plus récente)…",
+	"bridge.launcher.install_failed": "Le pont n'a pas pu être téléchargé ({reason}). Rien n'a été installé. Réessaie, ou récupère-le sur https://agentplugged.ai.",
+	"bridge.launcher.update_failed": "Le pont le plus récent n'a pas pu être téléchargé ({reason}) : celui qui est installé est gardé.",
 	"workflow.title": "Workflow Git (branches, CI, fusions, revue)",
 	"workflow.recommended": "(recommandé)",
 	"workflow.intro": "Je te propose ce qui convient à un créateur solo : {line}. Réponds oui pour tout garder, non pour choisir point par point.",
@@ -11225,6 +11344,7 @@ const fr = {
 	"init.sync.done": "Fichiers de tes outils IA écrits ({count} créés ou mis à jour).",
 	"init.sync.skipped": "Pas de sync pour l'instant : lance `npx agentplugged sync` quand tu veux.",
 	"init.done.noah": "C'est prêt. Ouvre {tool} dans ce dossier et écris : noah ?",
+	"init.link.hint": "Pour le relier à ton application web : `npx agentplugged pair`",
 	"init.done.noah.several": "C'est prêt. Ouvre l'un de tes outils ({tools}) dans ce dossier et écris : noah ?",
 	"init.done.sync_first": "Ensuite : lance `npx agentplugged sync`, puis ouvre {tool} dans ce dossier et écris : noah ?",
 	"init.done.sync_first.several": "Ensuite : lance `npx agentplugged sync`, puis ouvre l'un de tes outils ({tools}) dans ce dossier et écris : noah ?",
@@ -11919,16 +12039,16 @@ function questionToolOf(options) {
 * in the reference, section « Tool: <name> », and in the skills.
 */
 const TOOL_DESCRIPTIONS = {
-	state: "Read-only. Actions: get (ONE option only), next, trace, merge_order, environment. See reference/tool-state.md",
-	checkpoint: "Validation points. Actions: open (before asking the creator), decide (only a point the creator did not keep), measures, gap. Never answer for the creator. See reference/tool-checkpoint.md",
-	chat: "Ask the creator. Actions: ask, answer (only the creator's own words in quote, or via question_tool), stack_open, stack_ask, stack_answer, table. Never answer, reword or waive for the creator. See reference/tool-chat.md",
-	story: "Actions: start (only in its workdir), status, progress, result (end with it), pr (never merge), ci, deviation, lift_deviation, leave_fast_track, merge_conflict, criterion, loop. Never skip hooks or push the main branch. See reference/tool-story.md",
-	review: "Actions: start, submit, triage, get, publish, audit, critique, tests, qa, ready, export. Never review a story you built. See reference/tool-review.md",
-	agent: "Activity, handovers. Actions: status, delegate (Noah only), workshop. agent = your own id. See reference/tool-agent.md",
-	guard: "Creator-only actions, sensitive data. Actions: request, check (refused means never), external_read, creator_action (only with their yes), read_sensitive, write_sensitive (never read salle/ or memory/ files directly). what = action. See reference/tool-guard.md",
-	plan: "Actions: sprint (the creator approves), defer, complete_deferred, course (change of mind). Never start a story an open deferred item locks. See reference/tool-plan.md",
-	memory: "Lessons. Actions: read (before your first answer), retrospective, record, promote_propose, promote. Never record or promote a lesson before the creator approved it. See reference/tool-memory.md",
-	measure: "Actions: cost (never invent an amount), usage, requirements, proof (real results only), run (a command the creator accepted). See reference/tool-measure.md"
+	state: "Read-only. Actions: get (ONE option), next, trace, merge_order, environment. Ref: tool-state",
+	checkpoint: "Validation points. Actions: open (before asking the creator; files in documents, as paths from the product root), decide (only a point the creator did not keep), measures, gap. Never answer for the creator. Ref: tool-checkpoint",
+	chat: "Ask the creator. Actions: ask, answer (only the creator's words in quote, or via question_tool), stack_open, stack_ask, stack_answer, table. Never answer, reword or waive for the creator. Ref: tool-chat",
+	story: "Actions: start (only in its workdir), status, progress, result (end with it), pr (never merge), ci, deviation, lift_deviation, leave_fast_track, merge_conflict, criterion, loop. Never skip hooks or push the main branch. Ref: tool-story",
+	review: "Actions: start, submit, triage, get, publish, audit, critique, tests, qa, ready, export. Never review a story you built. Ref: tool-review",
+	agent: "Actions: status, delegate (Noah only), summarize, pause, workshop. agent = your own id. Ref: tool-agent",
+	guard: "Creator-only actions, sensitive data. Actions: request, check (refused means never), external_read, call, creator_action (only with their yes), read_sensitive, write_sensitive (never read salle/ or memory/ files directly). what = action. Ref: tool-guard",
+	plan: "Actions: sprint (creator approves), defer, complete_deferred, course (change of mind). Never start a story an open deferred item locks. Ref: tool-plan",
+	memory: "Lessons. Actions: read (before first answer), retrospective, record, promote_propose, promote. Never record or promote a lesson before the creator approved it. Ref: tool-memory",
+	measure: "Actions: cost (never invent an amount), usage, requirements, proof (real results only), run (a command the creator accepted). Ref: tool-measure"
 };
 /** One field of a published schema: a type, and the values of a short enumeration. */
 function slim(field) {
@@ -13031,6 +13151,105 @@ async function findBridge(env, platform = process.platform) {
 		return;
 	}
 }
+/**
+* npm's own JavaScript program on Windows, where `npm` is a batch file that only runs through a
+* shell: the one next to Node, else the one that started this process. `undefined` when neither is
+* found.
+*/
+function npmProgram(env) {
+	return [join(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"), env.npm_execpath ?? ""].find((path) => path.endsWith("npm-cli.js") && existsSync(path));
+}
+/** Runs npm; no argument ever passes through a shell. */
+function realNpm(args, platform, env) {
+	return new Promise((resolve) => {
+		let output = "";
+		const program = platform === "win32" ? npmProgram(env) : void 0;
+		if (platform === "win32" && program === void 0) {
+			resolve({
+				code: -1,
+				output: "npm was not found next to Node"
+			});
+			return;
+		}
+		const options = {
+			env: {
+				...process.env,
+				...env
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			windowsHide: true
+		};
+		const child = program === void 0 ? spawn("npm", [...args], options) : spawn(process.execPath, [program, ...args], options);
+		child.stdout.on("data", (chunk) => {
+			output += chunk.toString("utf8");
+		});
+		child.stderr.on("data", (chunk) => {
+			output += chunk.toString("utf8");
+		});
+		child.on("error", (error) => resolve({
+			code: -1,
+			output: error.message
+		}));
+		child.on("close", (code) => resolve({
+			code: code ?? -1,
+			output
+		}));
+	});
+}
+/**
+* `agentplugged bridge install`: gets the bridge, or its newest version, before the bridge itself
+* makes itself a service. The bridge is its own npm package, put in a folder of its own; the
+* pointer file then tells this launcher where it is. A bridge kept elsewhere
+* (`AGENTPLUGGED_BRIDGE_ENTRY`) is never touched. When the newest version cannot be fetched and a
+* bridge is already there, that one is used and the failure is said. Returns false when there is
+* no bridge at all at the end.
+*/
+async function installBridgePackage(environment, t) {
+	const { env } = environment;
+	const platform = environment.platform ?? process.platform;
+	if (env.AGENTPLUGGED_BRIDGE_ENTRY?.trim()) return await findBridge(env, platform) !== void 0;
+	const dir = bridgeInstallDir(env, platform);
+	const known = await findBridge(env, platform);
+	const source = env.AGENTPLUGGED_BRIDGE_PACKAGE?.trim() || `agentplugged-bridge@latest`;
+	if (dir === void 0 || !/^[^\s"'&|<>^%;$`-][^\s"'&|<>^%;$`]*$/.test(source)) {
+		environment.stderr(`${t("bridge.launcher.install_failed", { reason: "folder" })}\n`);
+		return known !== void 0;
+	}
+	const folder = join(dir, "package");
+	environment.stdout(`${t("bridge.launcher.installing")}\n`);
+	try {
+		await mkdir(folder, { recursive: true });
+		const manifest = join(folder, "package.json");
+		if (!await isFile(manifest)) await writeFile(manifest, "{ \"private\": true }\n");
+		const args = [
+			"install",
+			"--prefix",
+			folder,
+			"--omit=dev",
+			"--no-audit",
+			"--no-fund",
+			"--loglevel=error",
+			source
+		];
+		const done = await (environment.runNpm ?? ((a) => realNpm(a, platform, env)))(args);
+		if (done.code !== 0) throw new Error(done.output.trim().split("\n")[0] ?? "npm");
+		const dependencies = JSON.parse(await readFile(manifest, "utf8")).dependencies;
+		const name = Object.keys(dependencies ?? {})[0];
+		if (name === void 0) throw new Error("no package");
+		const entry = join(folder, "node_modules", name, "dist", "bin.js");
+		if (!await isFile(entry)) throw new Error("no program");
+		await writeFile(join(dir, BRIDGE_POINTER_FILE), `${JSON.stringify({ entry })}\n`);
+		return true;
+	} catch (error) {
+		const reason = error instanceof Error ? error.message.slice(0, 200) : "unknown";
+		environment.stderr(`${t(known === void 0 ? "bridge.launcher.install_failed" : "bridge.launcher.update_failed", { reason })}\n`);
+		return known !== void 0;
+	}
+}
 /** Runs the bridge's program with `args`; resolves with its exit code (1 when a signal ended it). */
 function runProgram(entry, args, environment, failed) {
 	return new Promise((resolve) => {
@@ -13079,12 +13298,15 @@ function runProgram(entry, args, environment, failed) {
 * nothing is left half done: the pairing is entirely the bridge's.
 */
 async function runBridgeLauncher(environment, t) {
+	if (environment.argv[0] === "bridge" && environment.argv[1] === "install") {
+		if (!await installBridgePackage(environment, t)) return 1;
+	}
 	const entry = await findBridge(environment.env, environment.platform);
 	if (entry === void 0) {
 		environment.stderr(`${t("bridge.launcher.not_installed")}\n`);
 		return 1;
 	}
-	return runProgram(entry, environment.argv[0] === "pair" ? environment.argv : environment.argv.slice(1), environment, t("bridge.launcher.not_installed"));
+	return runProgram(entry, environment.argv[0] === "pair" || environment.argv[0] === "device" ? environment.argv : environment.argv.slice(1), environment, t("bridge.launcher.not_installed"));
 }
 //#endregion
 //#region src/story-text.ts
@@ -14373,7 +14595,8 @@ const NO_KEYCHAIN = {
 	writePresenceCredential: noKeychain,
 	readProductSecret: noKeychain,
 	writeProductSecret: noKeychain,
-	writeProductBackup: noKeychain
+	writeProductBackup: noKeychain,
+	readProductBackup: noKeychain
 };
 //#endregion
 //#region src/init-flow.ts
@@ -14528,11 +14751,18 @@ function formatProductKey(t, result, file) {
 		const lines = [t("key.export.done", { key_id: result.key_id })];
 		if (file === void 0) lines.push("", result.exported, "");
 		else lines.push(t("key.export.file", { path: file }));
+		if (result.key_ids !== void 0) lines.push(t("key.export.many", { count: String(result.key_ids.length) }));
+		if (result.missing !== void 0) lines.push(t("key.export.missing", {
+			count: String(result.missing.length),
+			key_ids: result.missing.join(", ")
+		}));
 		lines.push(t("key.export.hint"), "");
 		return lines.join("\n");
 	}
+	if (result.status === "older") return `${t("key.import.older", { key_id: result.key_id })}\n`;
 	const lines = [t(result.status === "already" ? "key.import.already" : "key.import.done", { key_id: result.key_id })];
 	if (result.replaced !== void 0) lines.push(t("key.import.replaced", { held_key_id: result.replaced }));
+	if (result.key_ids !== void 0) lines.push(t("key.import.many", { key_ids: result.key_ids.join(", ") }));
 	return `${lines.join("\n")}\n`;
 }
 function formatSeal(t, result) {
@@ -14576,6 +14806,48 @@ function formatInitProductKey(t, productKey) {
 	}
 }
 //#endregion
+//#region src/link-hint.ts
+/**
+* The one line that ends `init` when this product is not linked to the web app yet: the command
+* that does it, nothing asked, nothing done. The method works alone either way. Whether the product
+* is already served is read from the bridge's own registry on this machine (a file the bridge
+* writes; this program never writes it), the way `bridge` finds its program: the command line only
+* launches the bridge and holds none of its logic.
+*/
+/** Where the bridge keeps its files on each system (the same folders the bridge uses). */
+function bridgeDataDir(env, platform) {
+	const given = env.AGENTPLUGGED_BRIDGE_HOME?.trim();
+	if (given) return resolve(given);
+	const home = env.USERPROFILE?.trim() || env.HOME?.trim() || homedir();
+	const usable = (value) => {
+		const trimmed = value?.trim();
+		return trimmed && isAbsolute(trimmed) ? trimmed : void 0;
+	};
+	if (platform === "win32") return join(usable(env.LOCALAPPDATA) ?? join(home, "AppData", "Local"), "AgentPlugged", "bridge");
+	if (platform === "darwin") return join(home, "Library", "Application Support", "AgentPlugged", "bridge");
+	return join(usable(env.XDG_STATE_HOME) ?? join(home, ".local", "state"), "agentplugged", "bridge");
+}
+async function readJson(path) {
+	try {
+		return JSON.parse(await readFile(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+/** True when this machine is linked to an account and serves the product in `root`. */
+async function isLinkedToWebApp(root, env, platform) {
+	const dir = bridgeDataDir(env, platform);
+	if (await readJson(join(dir, "binding.json")) === void 0) return false;
+	const registry = await readJson(join(dir, "products.json"));
+	const same = (a, b) => platform === "win32" ? resolve(a).toLowerCase() === resolve(b).toLowerCase() : resolve(a) === resolve(b);
+	return (registry?.products ?? []).some((entry) => typeof entry.path === "string" && same(entry.path, root));
+}
+/** The line, or nothing when the product is linked already. */
+async function linkHint(t, root, env, platform) {
+	if (await isLinkedToWebApp(root, env, platform)) return void 0;
+	return `\n${t("init.link.hint")}\n`;
+}
+//#endregion
 //#region src/migrate-text.ts
 /** One change of a step the creator should know, on one line. */
 function noteLine(t, note) {
@@ -15089,7 +15361,8 @@ function formatNext(t, result) {
 		if (review.untriaged > 0) lines.push(t("next.review.untriaged", { count: review.untriaged }));
 	}
 	if (result.independent === true) lines.push(t("next.independent"));
-	if (result.stop === true) lines.push(t("next.stop"));
+	if (result.paused !== void 0) lines.push(t(result.paused.reason === "emergency_stop" ? "next.paused.stopped" : "next.paused", { since: displayText(result.paused.since) }));
+	else if (result.stop === true) lines.push(t("next.stop"));
 	const morning = result.morning;
 	if (morning !== void 0 && morning.done_total + morning.decided_total > 0) lines.push(t("next.morning", {
 		done: morning.done_total,
@@ -15184,6 +15457,7 @@ function nextJson(result) {
 		...result.point === void 0 ? {} : { point: { ...result.point } },
 		...result.independent === true ? { independent: true } : {},
 		...result.stop === true ? { stop: true } : {},
+		...result.paused === void 0 ? {} : { paused: { ...result.paused } },
 		...result.pile === void 0 ? {} : { pile: {
 			stack: [...result.pile.stack],
 			apart: [...result.pile.apart],
@@ -16553,7 +16827,7 @@ async function runMcp(environment, t, files, engineAny) {
 				},
 				folders: new NodeFolderReader(),
 				commonMemory: new NodeCommonMemory(),
-				usageTraces: new NodeUsageTraces({ root: environment.cwd }),
+				usageTraces: new NodeUsageTraces({ root: productRootOf(environment.cwd) }),
 				ciReader: ciReaderOf(environment),
 				testReferences: new GitTestReferences({ cwd: environment.cwd }),
 				proofRunner: new NodeProofRunner({ root: environment.cwd }),
@@ -16639,7 +16913,7 @@ async function runHook(environment, t, rest) {
 		decision: "deny",
 		reason: ANTIGRAVITY_UNCHECKED_REASON
 	});
-	const root = productRootOf(environment.cwd);
+	const root = productRootOf$1(environment.cwd);
 	const home = environment.env.USERPROFILE?.trim() || environment.env.HOME?.trim() || homedir();
 	const keys = keyStoreOf(environment.env);
 	const journal = new GitStateStore({
@@ -16718,7 +16992,9 @@ const SYNC_WARNING_KEYS = {
 	kept: "sync.warning.kept",
 	description_too_long: "sync.warning.description_too_long",
 	unknown_setting: "sync.warning.unknown_setting",
-	local_engine: "sync.warning.local_engine"
+	local_engine: "sync.warning.local_engine",
+	gemini_legacy: "sync.warning.gemini_legacy",
+	gemini_unproven: "sync.warning.gemini_unproven"
 };
 /** Stands for the shipped method in commands that never read it. */
 const METHOD_UNAVAILABLE = {
@@ -16743,6 +17019,23 @@ function shippedMethodOrUnavailable() {
 		return METHOD_UNAVAILABLE;
 	}
 }
+/**
+* The environment the bridge is launched with: it also learns where this engine's program is, so
+* that it can run the same engine to make a product the creator asks for from a device. A value the
+* creator gave is kept; nothing is added when the program cannot be found (a test, a bundle).
+*/
+function withEngineEntry(env) {
+	if (env.AGENTPLUGGED_ENGINE_ENTRY?.trim()) return env;
+	try {
+		const entry = fileURLToPath(new URL("./bin.js", import.meta.url));
+		return existsSync(entry) ? {
+			...env,
+			AGENTPLUGGED_ENGINE_ENTRY: entry
+		} : env;
+	} catch {
+		return env;
+	}
+}
 /** Options that only change how the engine version is checked: left out of the quoted command. */
 const ENGINE_FLAGS = /* @__PURE__ */ new Set(["--engine-any", "--upgrade-engine"]);
 /**
@@ -16781,7 +17074,7 @@ const SYNC_GROUPS = [
 ];
 function groupTitle(t, group) {
 	if (group === "shared") return t("sync.group.shared");
-	if (group === "antigravity") return "Antigravity CLI + Gemini CLI";
+	if (group === "antigravity") return "Antigravity CLI";
 	return TOOL_CATALOG.find((spec) => spec.id === group)?.name ?? group;
 }
 /**
@@ -16834,6 +17127,10 @@ function formatSync(t, root, result, locale = "en") {
 		const fallbacks = result.fallbacks.map((fallback) => `  ${formatFallback(t, locale, fallback)}`);
 		text += `\n${t("sync.fallbacks.title")}\n${fallbacks.join("\n")}\n`;
 	}
+	if (result.geminiCleanup !== void 0) {
+		if (result.geminiCleanup.listed > 0) text += `\n${t("sync.gemini.confirm")}\n`;
+		else if (result.entries.length === 0) text += `\n${t("sync.gemini.nothing")}\n`;
+	}
 	text += formatSyncRules(t, result.rules);
 	if (result.codexTrustReminder) text += `\n${t("sync.codex_trust")}\n`;
 	if (result.cursorHooksReminder) text += `\n${t("sync.cursor_hooks")}\n`;
@@ -17247,10 +17544,10 @@ async function main(rawEnvironment) {
 	let environment = rawEnvironment;
 	const locale = localeOf(environment.env, environment.systemLocale);
 	const t = createTranslator(locale);
-	if (environment.argv[0] === "bridge" || environment.argv[0] === "pair") return await runBridgeLauncher({
+	if (environment.argv[0] === "bridge" || environment.argv[0] === "pair" || environment.argv[0] === "device") return await runBridgeLauncher({
 		argv: environment.argv,
 		cwd: environment.cwd,
-		env: environment.env,
+		env: withEngineEntry(environment.env),
 		...environment.platform === void 0 ? {} : { platform: environment.platform },
 		stdout: environment.stdout,
 		stderr: environment.stderr
@@ -17260,7 +17557,7 @@ async function main(rawEnvironment) {
 			environment.stderr(formatError(t, reviewNotInteractive("update")));
 			return 1;
 		}
-		const root = productRootOf(environment.cwd);
+		const root = productRootOf$1(environment.cwd);
 		return await runUpdate({
 			args: environment.argv.slice(1),
 			cwd: root,
@@ -17285,7 +17582,7 @@ async function main(rawEnvironment) {
 		}
 		return await runEval({
 			args: environment.argv.slice(1),
-			root: productRootOf(environment.cwd),
+			root: productRootOf$1(environment.cwd),
 			env: environment.env,
 			...methodDir === void 0 ? {} : { methodDir },
 			stdout: environment.stdout,
@@ -17325,6 +17622,7 @@ async function main(rawEnvironment) {
 	let rawOption = false;
 	let unverifiedOption = false;
 	let yesOption = false;
+	let cleanGeminiOption = false;
 	let toolsOption;
 	let permissionsOption;
 	let noSyncOption = false;
@@ -17395,6 +17693,7 @@ async function main(rawEnvironment) {
 					type: "boolean",
 					short: "y"
 				},
+				"clean-gemini": { type: "boolean" },
 				tools: { type: "string" },
 				permissions: { type: "string" },
 				"no-sync": { type: "boolean" },
@@ -17455,6 +17754,7 @@ async function main(rawEnvironment) {
 		rawOption = parsed.values.raw === true;
 		unverifiedOption = parsed.values.unverified === true;
 		yesOption = parsed.values.yes === true;
+		cleanGeminiOption = parsed.values["clean-gemini"] === true;
 		toolsOption = parsed.values.tools;
 		permissionsOption = parsed.values.permissions;
 		noSyncOption = parsed.values["no-sync"] === true;
@@ -17548,7 +17848,7 @@ async function main(rawEnvironment) {
 			return 1;
 		}
 		try {
-			const root = productRootOf(environment.cwd);
+			const root = productRootOf$1(environment.cwd);
 			return await runMcp({
 				...environment,
 				cwd: root
@@ -17586,7 +17886,7 @@ async function main(rawEnvironment) {
 		return failCode;
 	}
 	const initOnly = [
-		...yesOption ? ["--yes"] : [],
+		...yesOption && !(command === "sync" && cleanGeminiOption) ? ["--yes"] : [],
 		...toolsOption === void 0 ? [] : ["--tools"],
 		...noSyncOption ? ["--no-sync"] : []
 	];
@@ -17594,6 +17894,10 @@ async function main(rawEnvironment) {
 		reportError(invalidArguments(`${command}: ${initOnly.join(" ")}`));
 		return failCode;
 	}
+	if (cleanGeminiOption && command !== "sync" && registry.names().includes(command)) {
+		reportError(invalidArguments(`${command}: --clean-gemini`));
+		return failCode;
+	}
 	if (channelOption !== void 0 && command !== "init" && registry.names().includes(command)) {
 		reportError(invalidArguments(`${command}: --channel`));
 		return failCode;
@@ -17827,6 +18131,11 @@ async function main(rawEnvironment) {
 				return failCode;
 			}
 			input = prepared;
+		} else if (command === "sync") {
+			if (cleanGeminiOption) input = {
+				clean_gemini: true,
+				...yesOption ? { yes: true } : {}
+			};
 		} else if (command === "journal") {
 			const [action, ...extra] = rest;
 			if (action !== "sync" && action !== "status" || extra.length > 0) {
@@ -18107,6 +18416,8 @@ async function main(rawEnvironment) {
 				} else environment.stdout(`\n${t("init.sync.skipped")}\n`);
 				environment.stdout(`\n${formatNextStep(t, result.value.targetedTools, synced)}`);
 			}
+			const hint = await linkHint(t, files.root, environment.env, environment.platform ?? process.platform);
+			if (hint !== void 0) environment.stdout(hint);
 			if (scripted && machineReport?.blocking === true) {
 				environment.stderr(`${t("doctor.blocking", { list: machineReport.items.filter((item) => item.status === "fail").map((item) => locale === "fr" ? item.text.fr : item.text.en).join(" ; ") })}\n`);
 				exitCode = 1;