@nightkatana/kronosys-app 1.0.0-beta.2 → 1.0.0-beta.21

package/lib/taskParsing.ts

@@ -7,44 +7,126 @@ const AUTO_TAG_COMBINED = /(?:^|\s)#([^\s#]+)|(?<=[^\s#])#([^\s#]+)/g;
 
 /**
  * Détection des `@projet` (mêmes idées que les `#tags`).
+ * @deprecated Utiliser {@link findProjectTokens} pour `@` et `!`.
  */
 const AUTO_PROJECT_COMBINED = /(?:^|\s)@([^\s@]+)|(?<=[^\s@])@([^\s@]+)/g;
 
+type ProjectTokenMatch = {
+  start: number;
+  end: number;
+  plain: boolean;
+  sigil: "@" | "!";
+  projRaw: string;
+  loc?: string;
+};
+
 /**
- * `@projet#suffixe` : étiquette liée à un projet (stockée comme `projet#suffixe`, sans `@`).
- * Traitée avant les `@projet` seuls pour ne pas confondre le corps `projet#…` avec un nom de projet.
+ * Repère les jetons `@projet`, `!projet`, `@p#t` et `!p#t` (ordre d’apparition dans la chaîne).
+ *
+ * - `@` : uniquement après début de chaîne ou un espace (évite `courriel@domaine`).
+ * - `!` : idem **ou** collé au caractère précédent (comme les `#tags`), ex. `Courrier!perso#dentiste`.
  */
-const PROJECT_SCOPED_AT = /(?:^|\s)@([^\s@#]+)#([^\s#]+)/g;
+export function findProjectTokens(raw: string): ProjectTokenMatch[] {
+  const norm = raw.replace(/\s+/g, " ").trim();
+  /** Jetons `@` / `!` précédés d’une frontière « début ou espace ». */
+  const reBoundary = /(?:^|\s)([@!])([^\s@!#]+)(?:#([^\s#]+))?/g;
+  /** `!` seul : autorisé après un caractère non blanc, non `!`, non `#` (aligné sur les `#tags` collés). */
+  const reBangGlued = /(?<=[^\s!#])(!)([^\s@!#]+)(?:#([^\s#]+))?/g;
+
+  const pushMatch = (
+    out: ProjectTokenMatch[],
+    sigil: "@" | "!",
+    projRaw: string,
+    locRaw: string | undefined,
+    start: number,
+    fullLen: number,
+  ) => {
+    const end = start + fullLen;
+    const proj = projRaw.trim();
+    if (!proj) {
+      return;
+    }
+    if (locRaw !== undefined && locRaw.length > 0) {
+      const loc = locRaw.trim();
+      if (!loc || loc.includes("#")) {
+        return;
+      }
+      out.push({ start, end, plain: false, sigil, projRaw: proj, loc });
+    } else if (!proj.includes("#")) {
+      out.push({ start, end, plain: true, sigil, projRaw: proj });
+    }
+  };
 
-/** Extrait les jetons `@projet#suffixe` et retourne le texte restant. */
-export function stripScopedProjectAtTokens(raw: string): {
+  const buf: ProjectTokenMatch[] = [];
+  let m: RegExpExecArray | null;
+  while ((m = reBoundary.exec(norm)) !== null) {
+    pushMatch(buf, m[1] as "@" | "!", m[2], m[3], m.index, m[0].length);
+  }
+  while ((m = reBangGlued.exec(norm)) !== null) {
+    pushMatch(buf, "!", m[2], m[3], m.index, m[0].length);
+  }
+
+  buf.sort((a, b) => a.start - b.start || b.end - a.end);
+  const out: ProjectTokenMatch[] = [];
+  let lastEnd = -1;
+  for (const t of buf) {
+    if (t.start < lastEnd) {
+      continue;
+    }
+    out.push(t);
+    lastEnd = t.end;
+  }
+  return out;
+}
+
+/** Retire uniquement les jetons de portée `@p#t` / `!p#t` (les `@p` / `!p` simples restent). */
+function stripScopedProjectSigilTokens(raw: string): {
   core: string;
   scopedTags: string[];
   scopedProjectHint?: string;
+  scopedHintPersonal?: boolean;
 } {
+  const norm = raw.replace(/\s+/g, " ").trim();
+  const tokens = findProjectTokens(norm).filter((t) => !t.plain);
   const scopedTags: string[] = [];
-  let scopedProjectHint: string | undefined;
   const seen = new Set<string>();
-  const core = raw
-    .replace(PROJECT_SCOPED_AT, (_full, g1: string, g2: string) => {
-      const proj = (g1 || "").trim();
-      const loc = (g2 || "").trim();
-      if (!proj || !loc) {
-        return "";
-      }
-      if (!scopedProjectHint) {
-        scopedProjectHint = proj;
-      }
-      const canon = `${proj}#${loc}`;
-      const k = canon.toLowerCase();
-      if (!seen.has(k)) {
-        seen.add(k);
-        scopedTags.push(canon);
-      }
-      return "";
-    })
-    .replace(/\s+/g, " ")
-    .trim();
+  let scopedProjectHint: string | undefined;
+  let scopedHintPersonal: boolean | undefined;
+  for (const t of tokens) {
+    if (!t.loc) {
+      continue;
+    }
+    const proj = normalizeProjectKey(t.projRaw);
+    const loc = t.loc.trim();
+    if (!proj || !loc) {
+      continue;
+    }
+    if (scopedProjectHint === undefined) {
+      scopedProjectHint = proj;
+      scopedHintPersonal = t.sigil === "!";
+    }
+    const canon = `${proj}#${loc}`;
+    const k = canon.toLowerCase();
+    if (!seen.has(k)) {
+      seen.add(k);
+      scopedTags.push(canon);
+    }
+  }
+  let core = norm;
+  for (const tok of [...tokens].sort((a, b) => b.start - a.start)) {
+    core = `${core.slice(0, tok.start)} ${core.slice(tok.end)}`;
+  }
+  core = core.replace(/\s+/g, " ").trim();
+  return { core, scopedTags, scopedProjectHint, scopedHintPersonal };
+}
+
+/** @deprecated Préférer {@link stripProjectsAndTakeFirst} ; conservé pour tests et rétrocompat. */
+export function stripScopedProjectAtTokens(raw: string): {
+  core: string;
+  scopedTags: string[];
+  scopedProjectHint?: string;
+} {
+  const { core, scopedTags, scopedProjectHint } = stripScopedProjectSigilTokens(raw);
   return { core, scopedTags, scopedProjectHint };
 }
 
@@ -92,40 +174,64 @@ export function filterTaskTagsForProject(tags: string[], project: string | null
   return tags.filter((t) => isTagAllowedForProject(t, p));
 }
 
-/** Retire les `@projet` simples et retient le premier projet (une seule assignation par tâche). */
-function stripPlainProjectsAndTakeFirst(raw: string): { core: string; project?: string } {
+/** Retire les `@projet` / `!projet` simples (tous les jetons plain) et retient le **premier** en ordre de lecture. */
+function stripPlainProjectSigilTokensAndTakeFirst(raw: string): {
+  core: string;
+  project?: string;
+  plainPersonal?: boolean;
+} {
+  const norm = raw.replace(/\s+/g, " ").trim();
+  const tokens = findProjectTokens(norm).filter((t) => t.plain);
   let first: string | undefined;
-  const core = raw
-    .replace(AUTO_PROJECT_COMBINED, (_full, g1: string, g2: string) => {
-      const body = (g1 || g2 || "").trim();
-      if (body && !body.includes("#") && !first) {
-        first = normalizeProjectKey(body);
-      }
-      return "";
-    })
-    .replace(/\s+/g, " ")
-    .trim();
-  return { core, project: first };
+  let plainPersonal: boolean | undefined;
+  for (const t of tokens) {
+    if (first === undefined) {
+      first = normalizeProjectKey(t.projRaw);
+      plainPersonal = t.sigil === "!";
+    }
+  }
+  let core = norm;
+  for (const tok of [...tokens].sort((a, b) => b.start - a.start)) {
+    core = `${core.slice(0, tok.start)} ${core.slice(tok.end)}`;
+  }
+  core = core.replace(/\s+/g, " ").trim();
+  return { core, project: first, plainPersonal };
 }
 
-/** Retire `@projet#suffixe` puis `@projet` ; fusionne l’indice de projet issu des jetons liés. */
-export function stripProjectsAndTakeFirst(raw: string): { core: string; project?: string; scopedTags: string[] } {
-  const { core: c0, scopedTags, scopedProjectHint } = stripScopedProjectAtTokens(raw);
-  const { core, project: plainProject } = stripPlainProjectsAndTakeFirst(c0);
+/**
+ * Retire `@p#t` / `!p#t` puis `@p` / `!p` ; fusionne l’indice de projet (premier jeton plain,
+ * sinon premier indice issu d’un jeton de portée).
+ */
+export function stripProjectsAndTakeFirst(raw: string): {
+  core: string;
+  project?: string;
+  scopedTags: string[];
+  /** Vrai lorsque le projet retenu provient d’un jeton `!` (projet personnel). */
+  personalProject: boolean;
+} {
+  const { core: c0, scopedTags, scopedProjectHint, scopedHintPersonal } = stripScopedProjectSigilTokens(raw);
+  const { core, project: plainProject, plainPersonal } = stripPlainProjectSigilTokensAndTakeFirst(c0);
   const project = plainProject ?? scopedProjectHint;
-  return { core, project, scopedTags };
+  const personalFlag =
+    plainProject !== undefined ? plainPersonal === true : scopedHintPersonal === true;
+  return {
+    core,
+    project,
+    scopedTags,
+    personalProject: Boolean(project && personalFlag),
+  };
 }
 
 export function normalizeProjectKey(s: string): string {
-  return s.replace(/^@+/, "").trim();
+  return s.replace(/^[@!]+/, "").trim();
 }
 
 /**
- * Si le brouillon contient au moins un `@`, met à jour le projet (ou null si aucun jeton valide).
+ * Si le brouillon contient au moins un `@` ou `!`, met à jour le projet (ou null si aucun jeton valide).
  * Sinon ne pas modifier le champ projet côté API (`undefined`).
  */
 export function resolveProjectForTaskUpdate(rawTitle: string): string | null | undefined {
-  if (!/@/.test(rawTitle)) {
+  if (!/[@!]/.test(rawTitle)) {
     return undefined;
   }
   const { project } = stripProjectsAndTakeFirst(rawTitle);
@@ -133,18 +239,49 @@ export function resolveProjectForTaskUpdate(rawTitle: string): string | null | u
 }
 
 /**
- * Projet à enregistrer à partir d’une ligne de tâche complète (champ unique avec `#`, `@`, `@p#t`).
- * Aucun `@` dans la chaîne ⇒ aucun projet (`null`). Sinon, premier projet déduit comme à la saisie.
+ * Lorsque le titre contient `@` ou `!`, indique si le projet déduit est **personnel** (`!`).
+ * Sinon `undefined` (ne pas modifier `personalProject` côté API).
+ */
+export function resolvePersonalProjectForTaskUpdate(rawTitle: string): boolean | undefined {
+  if (!/[@!]/.test(rawTitle)) {
+    return undefined;
+  }
+  const { project, personalProject } = stripProjectsAndTakeFirst(rawTitle);
+  if (!project) {
+    return false;
+  }
+  return personalProject;
+}
+
+/**
+ * Projet à enregistrer à partir d’une ligne de tâche complète (champ unique avec `#`, `@`, `!`, `@p#t`, `!p#t`).
+ * Aucun `@` ni `!` dans la chaîne ⇒ aucun projet (`null`). Sinon, premier projet déduit comme à la saisie.
  */
 export function resolveProjectFromFullTaskLine(rawTitle: string): string | null {
   const t = rawTitle.replace(/\s+/g, " ").trim();
-  if (!/@/.test(t)) {
+  if (!/[@!]/.test(t)) {
     return null;
   }
   const { project } = stripProjectsAndTakeFirst(t);
   return project ? normalizeProjectKey(project) : null;
 }
 
+/** Même logique que {@link resolveProjectFromFullTaskLine} avec le drapeau projet personnel. */
+export function resolveProjectMetaFromFullTaskLine(rawTitle: string): {
+  project: string | null;
+  personalProject: boolean;
+} {
+  const t = rawTitle.replace(/\s+/g, " ").trim();
+  if (!/[@!]/.test(t)) {
+    return { project: null, personalProject: false };
+  }
+  const { project, personalProject } = stripProjectsAndTakeFirst(t);
+  return {
+    project: project ? normalizeProjectKey(project) : null,
+    personalProject: Boolean(project && personalProject),
+  };
+}
+
 /** Découpe le titre brut pour afficher le texte et les segments `#tag` comme pastilles (mêmes règles que {@link parseTaskWithAutoTags}). */
 export function splitTaskTitleSegments(raw: string): Array<{ kind: "text" | "tag"; value: string }> {
   const re = new RegExp(AUTO_TAG_COMBINED.source, "g");
@@ -205,10 +342,10 @@ function mergeDedupedTagLists(primary: string[], secondary: string[]): string[]
 }
 
 function collectAutoTagsFromRaw(raw: string): string[] {
-  const { core: afterScoped, scopedTags } = stripScopedProjectAtTokens(raw);
+  const { core, scopedTags } = stripProjectsAndTakeFirst(raw);
   const fromHash: string[] = [];
   const seen = new Set<string>();
-  for (const segment of splitTaskTitleSegments(afterScoped)) {
+  for (const segment of splitTaskTitleSegments(core)) {
     if (segment.kind !== "tag") {
       continue;
     }
@@ -235,47 +372,71 @@ function parseNameAndTagsFromCore(core: string): { name: string; tags: string[]
   return { name, tags };
 }
 
-export function parseTaskWithAutoTags(raw: string): { name: string; tags: string[]; project?: string } {
-  const { core, project, scopedTags } = stripProjectsAndTakeFirst(raw);
+export function parseTaskWithAutoTags(raw: string): {
+  name: string;
+  tags: string[];
+  project?: string;
+  personalProject: boolean;
+} {
+  const { core, project, scopedTags, personalProject } = stripProjectsAndTakeFirst(raw);
   const { name, tags } = parseNameAndTagsFromCore(core);
   const merged = mergeDedupedTagLists(scopedTags, tags);
-  return { name, tags: filterTaskTagsForProject(merged, project ?? null), project };
+  return {
+    name,
+    tags: filterTaskTagsForProject(merged, project ?? null),
+    project,
+    personalProject: Boolean(project && personalProject),
+  };
 }
 
 /**
  * Interprète une ligne de saisie rapide sous une tâche (`#tag`, `@projet`, `@p#code`, texte seul comme étiquette).
  * Les étiquettes retournées sont déjà filtrées par projet si un `@projet` est détecté dans la même chaîne.
  */
-export function parseQuickAddTagOrProjectLine(input: string): { tags: string[]; project?: string | null } {
+export function parseQuickAddTagOrProjectLine(input: string): {
+  tags: string[];
+  project?: string | null;
+  personalProject?: boolean;
+} {
   const v = input.trim();
   if (!v) {
     return { tags: [] };
   }
-  /** Seul `@` : retirer le projet (équivalent d’un clic « désactiver » sur la pastille projet enregistrée). */
-  if (v === "@") {
-    return { tags: [], project: null };
+  /** Seul `@` ou `!` : retirer le projet (équivalent d’un clic « désactiver » sur la pastille projet). */
+  if (v === "@" || v === "!") {
+    return { tags: [], project: null, personalProject: false };
   }
   const parsed = parseTaskWithAutoTags(v);
   const name = parsed.name.replace(/\s+/g, "").trim();
   if (parsed.tags.length === 0 && parsed.project === undefined && name.length > 0) {
-    return { tags: [normalizeTagKey(name)], project: undefined };
+    return { tags: [normalizeTagKey(name)], project: undefined, personalProject: undefined };
   }
   if (parsed.project === undefined) {
-    return { tags: parsed.tags, project: undefined };
+    return { tags: parsed.tags, project: undefined, personalProject: undefined };
   }
   const proj = parsed.project ? normalizeProjectKey(parsed.project) : null;
-  return { tags: parsed.tags, project: proj };
+  return {
+    tags: parsed.tags,
+    project: proj,
+    personalProject: proj ? parsed.personalProject : false,
+  };
 }
 
 /**
  * Fusionne plusieurs lignes choisies (ex. valeurs d’un `<select multiple>` : `#tag`, `@projet`, `@`).
  * Les étiquettes sont dédupliquées (casse ignorée). Le dernier jeton qui fixe le projet l’emporte ; `@` seul retire le projet.
  */
-export function mergeQuickAddFromOptionValues(values: string[]): { tags: string[]; project?: string | null } {
+export function mergeQuickAddFromOptionValues(values: string[]): {
+  tags: string[];
+  project?: string | null;
+  personalProject?: boolean;
+} {
   const seen = new Set<string>();
   const tags: string[] = [];
   let project: string | null | undefined = undefined;
   let projectTouched = false;
+  let personalProject: boolean | undefined = undefined;
+  let personalTouched = false;
 
   for (const raw of values) {
     const r = parseQuickAddTagOrProjectLine(raw);
@@ -295,12 +456,19 @@ export function mergeQuickAddFromOptionValues(values: string[]): { tags: string[
       projectTouched = true;
       project = r.project;
     }
+    if (r.personalProject !== undefined) {
+      personalTouched = true;
+      personalProject = r.personalProject;
+    }
   }
 
-  const out: { tags: string[]; project?: string | null } = { tags };
+  const out: { tags: string[]; project?: string | null; personalProject?: boolean } = { tags };
   if (projectTouched) {
     out.project = project;
   }
+  if (personalTouched) {
+    out.personalProject = personalProject;
+  }
   return out;
 }
 
@@ -339,22 +507,38 @@ export function taskTitleEditBaseline(storedName: string): string {
  * Même extraction que {@link parseTaskWithAutoTags}, mais sans rogner le titre :
  * nécessaire pour le champ de saisie contrôlé.
  */
-export function parseTaskDraftParts(raw: string): { name: string; tags: string[]; project?: string } {
-  const { core, project, scopedTags } = stripProjectsAndTakeFirst(raw);
+export function parseTaskDraftParts(raw: string): {
+  name: string;
+  tags: string[];
+  project?: string;
+  personalProject: boolean;
+} {
+  const { core, project, scopedTags, personalProject } = stripProjectsAndTakeFirst(raw);
   const fromCore = collectAutoTagsFromRaw(core);
   const tags = mergeDedupedTagLists(scopedTags, fromCore);
   const name = core.replace(new RegExp(AUTO_TAG_COMBINED.source, "g"), "");
-  return { name, tags, project };
+  return { name, tags, project, personalProject: Boolean(project && personalProject) };
 }
 
-function appendTagTokenToDraft(s: string, tag: string): string {
+function appendTagTokenToDraft(
+  s: string,
+  tag: string,
+  ctx?: { taskProject?: string | null; personalProject?: boolean },
+): string {
   const t = normalizeTagKey(tag).trim();
   if (!t) {
     return s;
   }
   const scoped = parseProjectScopedTag(t);
   if (scoped) {
-    const piece = `@${scoped.projectKey}#${scoped.localTag}`;
+    const pk = ctx?.taskProject ? normalizeProjectKey(String(ctx.taskProject)) : "";
+    const useBang =
+      Boolean(ctx?.personalProject) &&
+      pk.length > 0 &&
+      scoped.projectKey.toLowerCase() === pk.toLowerCase();
+    const piece = useBang
+      ? `!${scoped.projectKey}#${scoped.localTag}`
+      : `@${scoped.projectKey}#${scoped.localTag}`;
     const trimmed = s.replace(/\s+$/, "");
     return trimmed ? `${trimmed}${piece}` : piece;
   }
@@ -362,11 +546,20 @@ function appendTagTokenToDraft(s: string, tag: string): string {
   return trimmedEnd ? `${trimmedEnd}#${t}` : `#${t}`;
 }
 
-/** Reconstruit le brouillon (titre + #tags + `@projet#code` + @projet optionnel). */
-export function rebuildTaskDraftCore(name: string, tags: string[], project?: string): string {
+/** Reconstruit le brouillon (titre + #tags + jetons de portée + `@` / `!` projet optionnel). */
+export function rebuildTaskDraftCore(
+  name: string,
+  tags: string[],
+  project?: string,
+  personalProject?: boolean,
+): string {
   let s = name;
+  const pTrim = project?.trim();
+  const ctx = pTrim
+    ? { taskProject: normalizeProjectKey(pTrim), personalProject: Boolean(personalProject) }
+    : undefined;
   for (const t of tags) {
-    s = appendTagTokenToDraft(s, t);
+    s = appendTagTokenToDraft(s, t, ctx);
   }
   const p = project?.trim();
   if (p) {
@@ -377,18 +570,28 @@ export function rebuildTaskDraftCore(name: string, tags: string[], project?: str
     });
     if (!implied) {
       const trimmed = s.replace(/\s+$/, "");
-      s = trimmed ? `${trimmed}@${pk}` : `@${pk}`;
+      const projTok = personalProject ? `!${pk}` : `@${pk}`;
+      s = trimmed ? `${trimmed}${projTok}` : projTok;
     }
   }
   return s;
 }
 
-/** Reconstruit la chaîne « titre + #tags + `@p#t` [+ @projet] » alignée sur {@link parseTaskWithAutoTags}. */
-export function rebuildTaskRawString(name: string, tags: string[], project?: string | null): string {
+/** Reconstruit la chaîne « titre + #tags + `@p#t` / `!p#t` [+ @ ou ! projet] » alignée sur {@link parseTaskWithAutoTags}. */
+export function rebuildTaskRawString(
+  name: string,
+  tags: string[],
+  project?: string | null,
+  personalProject?: boolean,
+): string {
   const n = name.replace(/\s+/g, " ").trim();
+  const pTrim = project?.trim();
+  const ctx = pTrim
+    ? { taskProject: normalizeProjectKey(pTrim), personalProject: Boolean(personalProject) }
+    : undefined;
   let tagPart = n;
   for (const t of tags) {
-    tagPart = appendTagTokenToDraft(tagPart, t);
+    tagPart = appendTagTokenToDraft(tagPart, t, ctx);
   }
   const p = project?.trim();
   if (!p) {
@@ -403,27 +606,35 @@ export function rebuildTaskRawString(name: string, tags: string[], project?: str
     return tagPart;
   }
   const trimmed = tagPart.replace(/\s+$/, "");
-  return trimmed ? `${trimmed}@${pk}` : `@${pk}`;
+  const projTok = personalProject ? `!${pk}` : `@${pk}`;
+  return trimmed ? `${trimmed}${projTok}` : projTok;
 }
 
 /**
- * Chaîne pour le champ d’édition : nom stocké sans `#` / `@` + pastilles fusionnées + projet.
+ * Chaîne pour le champ d’édition : nom stocké sans `#` / `@` / `!` + pastilles fusionnées + projet.
  */
 export function displayRawTaskTitle(
   storedName: string,
   mergedTags: string[],
-  mergedProject?: string | null
+  mergedProject?: string | null,
+  mergedPersonalProject?: boolean,
 ): string {
   const { name: stripped } = parseTaskWithAutoTags(storedName);
   const base = stripped.replace(/\s+/g, " ").trim();
   const baseKey = base.toLowerCase();
   const suffixTags = mergedTags.filter((t) => normalizeTagKey(t).toLowerCase() !== baseKey);
+  const personal = Boolean(mergedPersonalProject);
+  const pTrim = mergedProject?.trim();
+  const pkForScoped =
+    pTrim && personal ? normalizeProjectKey(pTrim).toLowerCase() : "";
   const suffix = suffixTags
     .map((t) => {
       const tk = normalizeTagKey(t);
       const sc = parseProjectScopedTag(tk);
       if (sc) {
-        return `@${sc.projectKey}#${sc.localTag}`;
+        const useBang =
+          personal && sc.projectKey.toLowerCase() === pkForScoped;
+        return useBang ? `!${sc.projectKey}#${sc.localTag}` : `@${sc.projectKey}#${sc.localTag}`;
       }
       return `#${tk}`;
     })
@@ -445,13 +656,14 @@ export function displayRawTaskTitle(
     });
     if (!implied) {
       const trimmed = out.replace(/\s+$/, "");
-      out = trimmed ? `${trimmed}@${pk}` : `@${pk}`;
+      const projTok = personal ? `!${pk}` : `@${pk}`;
+      out = trimmed ? `${trimmed}${projTok}` : projTok;
     }
   }
   return out;
 }
 
-/** Ajoute un tag enregistré à la fin du brouillon (`#tag` ou `@projet#code`). */
+/** Ajoute un tag enregistré à la fin du brouillon (`#tag` ou `@projet#code` / `!projet#code`). */
 export function appendSavedTagToDraft(current: string, tag: string): string {
   const token = normalizeTagKey(tag);
   if (!token) {
@@ -459,9 +671,9 @@ export function appendSavedTagToDraft(current: string, tag: string): string {
   }
   const parsed = parseTaskDraftParts(current);
   const nextTags = mergeDedupedTagLists(parsed.tags, [token]);
-  const prevCore = rebuildTaskDraftCore(parsed.name, parsed.tags, parsed.project);
+  const prevCore = rebuildTaskDraftCore(parsed.name, parsed.tags, parsed.project, parsed.personalProject);
   const suff = current.startsWith(prevCore) ? current.slice(prevCore.length) : "";
-  const core = rebuildTaskDraftCore(parsed.name, nextTags, parsed.project);
+  const core = rebuildTaskDraftCore(parsed.name, nextTags, parsed.project, parsed.personalProject);
   return core + suff;
 }
 
@@ -474,17 +686,21 @@ export function removeSavedTagFromDraft(current: string, tag: string): string {
   const key = token.toLowerCase();
   const parsed = parseTaskDraftParts(current);
   const nextTags = parsed.tags.filter((t) => normalizeTagKey(t).toLowerCase() !== key);
-  return rebuildTaskRawString(parsed.name, nextTags, parsed.project ?? null);
+  return rebuildTaskRawString(parsed.name, nextTags, parsed.project ?? null, parsed.personalProject);
 }
 
-/** Retire le projet (`@projet`) du brouillon sans modifier le libellé ni les étiquettes. */
+/** Retire le projet (`@projet` / `!projet`) du brouillon sans modifier le libellé ni les étiquettes. */
 export function removeProjectFromDraft(current: string): string {
   const parsed = parseTaskDraftParts(current);
-  return rebuildTaskRawString(parsed.name, parsed.tags, null);
+  return rebuildTaskRawString(parsed.name, parsed.tags, null, false);
 }
 
-/** Ajoute un projet connu à la fin du brouillon (`@nom`, sans espace avant `@` si le cœur se termine déjà par du texte). */
-export function appendSavedProjectToDraft(current: string, project: string): string {
+/** Ajoute un projet connu à la fin du brouillon (`@nom` ou `!nom`). */
+export function appendSavedProjectToDraft(
+  current: string,
+  project: string,
+  opts?: { personal?: boolean },
+): string {
   const token = normalizeProjectKey(project);
   if (!token) {
     return current;
@@ -493,16 +709,30 @@ export function appendSavedProjectToDraft(current: string, project: string): str
   if (parsed.project && parsed.project.toLowerCase() === token.toLowerCase()) {
     return current;
   }
-  const core = rebuildTaskDraftCore(parsed.name, parsed.tags, token);
+  const personal = opts?.personal ?? false;
+  const core = rebuildTaskDraftCore(parsed.name, parsed.tags, token, personal);
   const suff = current.startsWith(core) ? current.slice(core.length) : "";
   return core + suff;
 }
 
-export function buildStartTaskFromInput(raw: string): { name: string; tags: string[]; project?: string } {
+export function buildStartTaskFromInput(raw: string): {
+  name: string;
+  tags: string[];
+  project?: string;
+  personalProject?: boolean;
+} {
   const trimmed = raw.trim();
-  const { name, tags, project } = parseTaskWithAutoTags(trimmed);
+  const { name, tags, project, personalProject } = parseTaskWithAutoTags(trimmed);
   const displayName = name || tags[0] || trimmed;
-  return { name: displayName, tags, project };
+  const out: { name: string; tags: string[]; project?: string; personalProject?: boolean } = {
+    name: displayName,
+    tags,
+  };
+  if (project) {
+    out.project = project;
+    out.personalProject = personalProject;
+  }
+  return out;
 }
 
 /**
@@ -512,24 +742,35 @@ export function buildStartTaskFromDraft(
   titleLine: string,
   pickerTags: string[],
   /** `undefined` : projet issu du titre ; chaîne vide : aucun projet (pastille désactivée). */
-  pickerProject: string | undefined
-): { name: string; tags: string[]; project?: string } {
+  pickerProject: string | undefined,
+  opts?: { pickerPersonalProject?: boolean },
+): { name: string; tags: string[]; project?: string; personalProject?: boolean } {
   const trimmed = titleLine.trim();
   const parsed = parseTaskWithAutoTags(trimmed);
   const allTags = mergeTagsForDisplay(trimmed, pickerTags);
   const project =
     pickerProject === undefined ? parsed.project : pickerProject.trim() ? pickerProject : undefined;
+  const personalProject =
+    pickerProject === undefined
+      ? parsed.personalProject
+      : pickerProject.trim()
+        ? opts?.pickerPersonalProject ?? false
+        : false;
   const tags = filterTaskTagsForProject(allTags, project ?? null);
   const displayName =
     parsed.name.trim() ||
     (tags.length > 0 ? tags[0] : "") ||
     trimmed ||
     (project ? normalizeProjectKey(project) : "");
-  return {
+  const out: { name: string; tags: string[]; project?: string; personalProject?: boolean } = {
     name: displayName,
     tags,
-    ...(project ? { project } : {}),
   };
+  if (project) {
+    out.project = project;
+    out.personalProject = personalProject;
+  }
+  return out;
 }
 
 export function normalizeTagKey(s: string): string {
@@ -624,21 +865,27 @@ export function mergeTagsForDisplay(rawName: string, storedTags?: string[] | nul
   return out;
 }
 
-export function formatTagDisplay(tag: string): string {
+export function formatTagDisplay(tag: string, opts?: { personalScoped?: boolean }): string {
   const trimmed = tag.trim();
   if (!trimmed) {
     return trimmed;
   }
   const scoped = parseProjectScopedTag(trimmed.replace(/^#/, ""));
   if (scoped) {
-    return `@${scoped.projectKey}#${scoped.localTag}`;
+    return opts?.personalScoped
+      ? `!${scoped.projectKey}#${scoped.localTag}`
+      : `@${scoped.projectKey}#${scoped.localTag}`;
   }
   const noHash = trimmed.replace(/^#/, "");
   return trimmed.startsWith("#") ? trimmed : `#${noHash}`;
 }
 
 /** Libellé lisible pour une pastille d’étiquette ; `defaultBucketLabel` remplace l’affichage de l’étiquette réservée {@link DEFAULT_FALLBACK_TASK_TAG}. */
-export function formatTagDisplayForTask(tag: string, defaultBucketLabel?: string): string {
+export function formatTagDisplayForTask(
+  tag: string,
+  defaultBucketLabel?: string,
+  opts?: { personalProject?: boolean; taskProject?: string | null },
+): string {
   const trimmed = normalizeTagKey(String(tag)).trim();
   if (!trimmed) {
     return "";
@@ -646,15 +893,25 @@ export function formatTagDisplayForTask(tag: string, defaultBucketLabel?: string
   if (trimmed.toLowerCase() === DEFAULT_FALLBACK_TASK_TAG && defaultBucketLabel?.trim()) {
     return defaultBucketLabel.trim();
   }
-  return formatTagDisplay(tag);
+  const sc = parseProjectScopedTag(trimmed);
+  const tp = opts?.taskProject;
+  const usePersonalScoped =
+    sc !== null &&
+    Boolean(opts?.personalProject && tp) &&
+    sc.projectKey.toLowerCase() === normalizeProjectKey(String(tp)).toLowerCase();
+  return formatTagDisplay(tag, { personalScoped: usePersonalScoped });
 }
 
-export function formatProjectDisplay(project: string): string {
+export function formatProjectDisplay(project: string, opts?: { personal?: boolean }): string {
   const trimmed = project.trim();
   if (!trimmed) {
     return trimmed;
   }
-  return trimmed.startsWith("@") ? trimmed : `@${normalizeProjectKey(trimmed)}`;
+  const k = normalizeProjectKey(trimmed);
+  if (opts?.personal) {
+    return trimmed.startsWith("!") ? trimmed : `!${k}`;
+  }
+  return trimmed.startsWith("@") ? trimmed : `@${k}`;
 }
 
 /**