Instrument de planification pour fondateurs

IdeaClyst

Transformez des idées brutes en plans SaaS concrets — en plaçant Claude et Codex au sein du même conseil.

Next.js 16 React 19 Local-first Port 5417 Sans BDD · Sans auth

Guide pas à pas

Le chemin le plus rapide depuis un dépôt fraîchement cloné jusqu'à un dossier de planification complet. Le mode simulation est activé par défaut — aucun CLI n'est nécessaire pour tout tester de bout en bout.

1

Installer les dépendances

Depuis la racine du projet :

npm install
2

Créer votre configuration

Copiez le fichier d'environnement d'exemple. Il utilise par défaut le mode simulation — aucun CLI requis.

cp .env.example .env.local
3

Démarrer le serveur de développement

Puis ouvrez http://localhost:5417 dans votre navigateur.

npm run dev
4

Démarrer une session d'idée

Sur la page d'accueil, cliquez sur « Démarrer une session d'idée » pour ouvrir le formulaire d'idée (/new).

5

Décrire votre idée

Donnez-lui un titre, rédigez l'idée (au moins une phrase, 10+ caractères), et choisissez un objectifvalidate · plan · build · pitch · refine. Ajoutez optionnellement un client cible, des contraintes ou une pile technologique préférée. Puis soumettez.

6

Observer le conseil délibérer

Vous atterrissez sur la page de la session, qui actualise toutes les 1,5 s. Les cinq étapes s'allument au fur et à mesure — terminé, en cours, en attente — et chaque résultat apparaît dès qu'il est prêt.

7

Lire votre dossier

Quand la session est terminée, les onglets de résultats se remplissent : Résumé, Backlog MVP, Risques, Tests de validation, Prochaines invites. Toutes les sessions passées sont accessibles sous /runs.

8

(Optionnel) Passer aux vrais CLIs

Pour obtenir de vrais résultats, définissez IDEACLYST_AGENT_MODE=cli dans .env.local, assurez-vous que les deux CLIs sont installés et connectés, puis redémarrez le serveur et lancez une nouvelle session. Un vrai conseil prend ~5–7 min (cinq appels de modèle en direct), contre instantané en mode simulation.

claude --version && codex login status
9

Retrouver les fichiers

Chaque session est sauvegardée sur disque sous .ideaclyst/runs/<runId>/ en tant que run.json plus des fichiers Markdown lisibles ou partageables hors de l'application.

!

Attention en développement : modifier un fichier en cours de session peut interrompre un conseil actif (l'orchestrateur s'exécute dans le même processus). Si cela se produit, redémarrez npm run dev et commencez une nouvelle session.

01Ce que c'est

IdeaClyst est une application Next.js locale qui transforme une idée de produit brute en un dossier de planification complet pour fondateur. Il ne s'agit pas d'une simple invite, mais de l'orchestration d'un conseil structuré — une délibération en cinq étapes entre deux outils d'IA en ligne de commande qui adoptent des rôles opposés et se critiquent mutuellement avant de rendre un verdict.

Imaginez une petite salle de conseil : un fondateur SaaS sceptique (Claude) et un CTO pragmatique (Codex) débattent de votre idée jusqu'à la mettre en forme. Le résultat est divisé en Résumé, Backlog MVP, Risques, Tests de validation, et Prochaines invites prêtes à coller.

Toute l'application repose sur une idée : deux modèles différents, adoptant des rôles adversariaux et lisant les travaux l'un de l'autre, produisent un plan plus pertinent que chacun séparément. Tout le reste — le stockage sur disque, l'interface de polling, le commutateur de mode — existe pour servir cette délibération.

Nouveau : une Étape 0 de recherche web (issue de surfagent) explore discrètement le marché et la concurrence pour ancrer chaque étape du conseil dans des données réelles — plus un mode Découverte d'idées (/discover) qui propose des idées à promouvoir en session. La recherche produit désormais un dossier structuré, une matrice concurrentielle, une carte des opportunités, des expériences de validation, un plan de distribution, des critères d'abandon, des notes sur le périmètre MVP, une critique de page d'accueil, une référence de veille, et un brief fondateur. Les candidats à la découverte bénéficient également de rapports d'idées complets avec fiches de notation, échelles d'offres, signaux de preuve, plans d'exécution, adéquation fondateur, critiques, étiquettes de source/fraîcheur des mots-clés, exports copiables, invites de transfert Claude/Codex, une bibliothèque sauvegardée, la personnalisation du profil fondateur, un radar de tendances, et une vue de comparaison côte à côte. La recherche est au mieux-effort et soumise à un mode (simulation/hors-ligne par défaut), donc une session n'échoue jamais si Chrome est absent. Voir le README pour les détails.

02Fonctionnalités en bref

Cœur

Conseil bi-agent

Cinq étapes alternées entre Claude et Codex, chaque agent lisant les sorties précédentes et critiquant l'autre.

Prêt à démo

Mode simulation par défaut

Résultats réalistes et adaptés à l'idée, sans aucun CLI installé. Une variable d'environnement suffit pour activer le vrai mode.

Temps réel

Résultats progressifs

Le résultat de chaque étape apparaît dès qu'il est prêt — la page de session interroge le disque toutes les 1,5 s.

Durable

Le disque fait foi

Chaque session persiste sous forme de run.json + fichiers Markdown. Un redémarrage du serveur ne perd aucun résultat.

Structuré

Dossier à onglets

Le plan final est automatiquement divisé en Résumé, Backlog MVP, Risques, Tests de validation & Prochaines invites.

Sécurisé

Sans shell, en bac à sable

Les CLIs sont lancés avec des arguments en tableau + stdin (pas d'injection) ; Codex tourne en lecture seule dans un répertoire temporaire jetable.

Résilient

Échec gracieux

Un CLI manquant ou défaillant marque la session comme échouée avec un message clair — les étapes déjà complétées sont préservées.

Portable

Artifacts Markdown

Chaque session produit également des fichiers .md lisibles par l'humain, partageables hors de l'application.

Zéro secret

Aucune clé gérée

IdeaClyst ne manipule jamais de clés API — les deux CLIs s'authentifient via leurs propres sessions locales.

Recherche

Kit de preuves

La recherche Surfagent produit RESEARCH_DOSSIER.json, un onglet kit, un brief fondateur, et des artifacts de marché autonomes.

Découverte

Rapports d'idées complets

Chaque candidat dispose d'une page de rapport avec adéquation business, échelle d'offre, pourquoi maintenant, preuves, écart de marché, cadre, mot-clé, adéquation fondateur, et critique.

Décision

Comparer et exporter

Les rapports de candidats peuvent être ajoutés à /compare et copiés en Markdown, JSON, résumé d'une page, ou invites d'implémentation et de révision Claude/Codex.

Personnel

Profil fondateur

/profile stocke localement compétences, capacité, risque, aisance commerciale, capital, accès au marché, et avantages concurrentiels.

Bibliothèque

Mes ressources

Sauvegardez des idées et rapports de candidats dans /library, alimenté par du JSON local et des fichiers Markdown sous .ideaclyst.

Tendances

Bibliothèque de signaux de marché

/trends, /insights, et /monitors transforment les découvertes locales en cartes de tendances, rapports d'insights de marché, et diffs concurrentiels/tendances réexécutables.

Mots-clés

Intelligence source-aware

Les sections de mots-clés des rapports indiquent la source et la fraîcheur, avec des données de snapshot optionnelles superposées aux estimations hors-ligne déterministes.

Navigation

Zones produit épurées

L'en-tête reste compact : Explorer contient Découvrir, Aujourd'hui, et Tendances ; Espace de travail contient Sessions, Bibliothèque, et Validation. Les outils avancés sont liés depuis ces pages.

Preuves

Audit des sources

/evidence indexe les sources de sessions, découvertes, et rapports avec confiance, fraîcheur, affirmations, et avertissements de preuves faibles.

Validation

Espaces de travail sprint

/validation, /validation/import, /validation/analytics, et /interviews transforment rapports, tests de prix, résultats collés, et personas acheteurs en une piste d'audit.

Construction

PRD, landing, et dossiers

Les rapports de candidats ouvrent désormais des espaces de travail pour entonnoir, page d'accueil, persona, conseiller, version de rapport, paquet d'export, et construction de l'idée, ancrés dans le rapport sauvegardé.

Opérations

Décisions et mémoire

Les décisions de rapport s'écrivent dans .ideaclyst/decisions, alimentent une mémoire de conseil compacte, et gardent inspectables les appels promus, mis en veille, tués, et validés.

Recherche

Couloirs de sources et cache

/settings/research modifie les modèles de couloirs de sources et affiche le cache à TTL/taille limités utilisé par la recherche, la reconnaissance, et l'extraction de pages lisibles.

03Architecture

IdeaClyst comporte quatre couches, et la discipline de conception est que une seule d'entre elles sait si vous êtes en mode simulation ou en mode CLI réel.

Couche 1 · Interface

Pages App Router

Accueil, formulaire d'idée (/new), liste des sessions (/runs), et une page de détail de session en direct qui interroge le serveur. Rendu client pur + fetch.

Couche 2 · API

Gestionnaires de routes

/api/runs crée une session et déclenche le conseil ; /api/runs/[id] retourne une session pour le polling ; /api/runs/[id]/research met en file d'attente une actualisation de recherche seule et répond immédiatement.

Couche 3 · Orchestrateur

Le pipeline en 5 étapes

orchestrator.ts séquence le conseil et persiste après chaque étape, y compris les fichiers structurés du kit de recherche créés lors de l'Étape 0.

Couche 4 · Agents + Stockage

Le point de jonction de mode & disque

agents/ est le seul code conscient du mode ; runs/store.ts lit & écrit la source de vérité sur disque.

// la seule branche qui connaît le mode — agents/index.ts
export async function runAgent(agent, prompt, ctx) {
  if (agentMode() === "mock")
    return runMock(ctx.run, ctx.stepKey);   // ignore le prompt, utilise la session structurée
  return agent === "claude"
    ? runClaude(prompt, runDir)            // vrai `claude` (sans -p), dans le répertoire de session
    : runCodex(prompt);                    // vrai `codex exec`
}

04Le conseil en 5 étapes

C'est le cœur de l'application. Les deux agents alternent, et le détail crucial se trouve dans la ligne « voit » de chaque étape — chaque agent lit des sorties précédentes spécifiques, ce qui en fait une délibération plutôt que cinq invites isolées.

Surfagent — recherche web Claude — fondateur SaaS sceptique Codex — CTO pragmatique
0
Surfagent · Recherche web

Étude de marché

Avant que le conseil délibère, Chrome sans interface explore le web pour le marché et les concurrents de l'idée, et rédige un mémo de recherche ainsi qu'un kit structuré qui ancre chaque étape suivante. Au mieux-effort : si Chrome est absent ou qu'une recherche est bloquée, un repli vers la synthèse hors-ligne est effectué — la session n'échoue jamais. Peut être désactivé par session depuis le formulaire d'idée ou mis en file d'attente plus tard comme actualisation en arrière-plan sans relancer le conseil.

Voit : brief d'idée + web en direct
1
Claude · Stratège produit

Stratégie produit

Teste sous pression l'idée pour en faire une stratégie crédible : le problème central & qui le ressent le plus, le levier le plus pertinent, le client cible & la disposition à payer, la différenciation, l'approche marché, et les hypothèses les plus risquées.

Voit : brief d'idée
2
Codex · CTO pragmatique

Architecture technique

Conçoit une architecture MVP légère et réalisable : pile recommandée & justification, modèle de données, services clés, APIs tierces, risques de développement, et ordre de construction approximatif. Signale tout ce qui est techniquement naïf dans la stratégie.

Voit : brief d'idée + stratégie Étape 1
3
Claude · Critique

Critique l'architecture

De retour en fondateur sceptique — attaque le plan du CTO sous l'angle produit/livraison : est-il sur-conçu pour un MVP ? Sert-il le levier ? Qu'est-ce qui doit être coupé pour livrer en semaines, pas en mois ?

Voit : brief d'idée + architecture Étape 2
4
Codex · Critique

Critique la stratégie

Le CTO contre-attaque sur la stratégie depuis un prisme de réalité d'ingénierie : quelles hypothèses sont techniquement coûteuses ou infaisables pour un MVP ? Où l'approche marché implique-t-elle un périmètre que l'équipe ne peut pas livrer rapidement ?

Voit : brief d'idée + stratégie Étape 1
5
Claude · Synthétiseur

Synthèse finale

Réconcilie tout en un dossier décisif, résolvant les désaccords avec une recommandation claire. Produit des en-têtes ## exacts : Résumé, Backlog MVP, Risques, Tests de validation, Prochaines invites.

Voit : brief É1 É2 É3 É4

L'échange croisé est l'essentiel. Codex s'appuie sur la stratégie de Claude (étape 2), puis chacun critique le domaine de l'autre (étapes 3 & 4), et Claude réconcilie les quatre en un verdict (étape 5). Après chaque étape, l'orchestrateur réécrit run.json et un fichier Markdown, de sorte que l'interface révèle les sorties une par une.

Découverte d'idées

La majeure partie d'IdeaClyst évalue une idée que vous apportez. La Découverte d'idées (la route /discover) fait l'inverse — elle trouve des idées pour vous, ancrées dans ce avec quoi les gens luttent réellement sur le web. La page blanche est la partie la plus difficile de la construction ; la Découverte la remplace par de véritables signaux de demande.

1 · Profil

Dites qui construit

Remplissez optionnellement /profile une fois pour que la découverte tienne compte des compétences, de l'accès aux acheteurs, du capital, du temps, du risque, et de l'aisance commerciale.

2 · Brief

Vous cadrez la recherche

Un marché ou espace — « applications visionOS », « IA pour comptables » — plus votre objectif et votre capacité de construction. Le contexte du profil fondateur est pré-rempli dans les notes et peut être édité par scout.

3 · Exploration

Surfagent balaie le web

Chrome sans interface explore des couloirs spécifiques à la source — Hacker News, Reddit, Product Hunt, GitHub, pages commerciales de critiques/prix, et le web général — pour des problèmes, « j'aimerais qu'il existe … », des lancements, et des écosystèmes d'implémentation.

4 · Lecture de marché

Un paysage honnête d'abord

Claude rédige une lecture sourcée de l'espace — un verdict d'une ligne, signaux de demande, concurrence, qui paie vraiment, et une perspective réaliste pour votre objectif. Il commence par les mauvaises nouvelles quand le marché est difficile.

5 · Carte des opportunités

Trouver la zone de levier

Le scout crée une carte douleur/concurrence élevées pour que vous puissiez voir les leviers nets, les idées encombrées mais validées, les paris exploratoires, et les passages probables avant de choisir un candidat.

6 · Concepts classés

Idées concrètes et comparables

Puis 5–7 candidats, classés par meilleure adéquation, chacun avec un levier, qui paie, effort de construction, force commerciale, risque majeur, adéquation, signal + source, score de confiance, et critères d'abandon.

7 · Rapport complet

Examinez avant de vous engager

Chaque candidat s'ouvre sur un rapport complet : fiche de notation des opportunités, adéquation business, échelle d'offre, pourquoi maintenant, signaux de preuve, écart de marché, plan d'exécution, adéquation de cadre, intelligence communautaire et mots-clés, adéquation fondateur, prisme de profil, et critique.

8 · Radar de tendances

Regarder les signaux s'accumuler

/trends collecte les termes de marché, notes de croissance des mots-clés, communautés liées, sources, et liens de candidats à partir des découvertes locales.

9 · Sauvegarder/comparer/exporter

Faire un choix plus éclairé

Sauvegardez des rapports dans /library, ajoutez-les à /compare, triez par scores, et copiez en Markdown, JSON, résumés d'une page, invites de construction, ou invites de révision seule.

10 · Promouvoir

Un clic vers le conseil

« Promouvoir au conseil » transforme un candidat en session normale et transporte la thèse du rapport, l'adéquation fondateur, l'offre principale, et le verdict de critique dans le brief du conseil.

Une fonctionnalité de premier plan. Comme la recherche, la Découverte est soumise au mode (candidats hors-ligne déterministes en simulation ; exploration en direct + synthèse en mode CLI) et au mieux-effort — elle retourne toujours des candidats, même hors-ligne ou quand une source est bloquée.

Les découvertes persistent sur disque sous .ideaclyst/discoveries/<id>/ (un discovery.json, MARKET_READ.md, OPPORTUNITY_MAP.md, CANDIDATES.md, et des artifacts de rapport/version), et la page de découverte actualise en direct, tout comme une session. Le radar de tendances écrit dans .ideaclyst/trends ; insights, moniteurs, décisions, exports, couloirs de sources, imports de validation, et entretiens s'écrivent dans leurs propres dossiers locaux sous .ideaclyst/. L'en-tête de l'application reste épuré : Explorer ouvre /discover, /today, et /trends ; Espace de travail ouvre sessions, bibliothèque, et validation. Comparer, preuves, décisions, insights, moniteurs, entretiens, clusters, et paramètres de recherche sont liés contextuellement depuis ces pages.

Intelligence de feuille de route

IdeaClyst peut lire la feuille de route d'un projet Threlmark — un gestionnaire de feuille de route local-first distinct — et la transformer en suggestions de croissance ancrées dans la réalité. Pointez-le vers un projet (la route /roadmap) et il propose de nouvelles fonctionnalités, produits dérivés, et services, chacun noté comme une carte de feuille de route et appuyé par de vraies preuves web. Examinez-les, puis renvoyez les meilleurs dans la Boîte de réception de Threlmark.

1 · Source

Pointer vers Threlmark

Lit la feuille de route de chaque projet directement depuis le disque (~/.threlmark) — en lecture seule — ou via l'API REST de Threlmark. Configurez-le sur la nouvelle page /settings ; les variables d'environnement ont toujours la priorité.

2 · Carte des lacunes

Connaître d'abord la feuille de route

Une lecture de couverture déterministe — quelles catégories sont solides, lesquelles sont minces ou totalement absentes, ce qui est fait ou encore ouvert — cadre l'analyse avant que tout modèle s'exécute.

3 · Trois couloirs

Fonctionnalités · dérivés · services

Trois couloirs de recherche indépendants balaient le web : lacunes→fonctionnalités, adjacence→dérivés, productisation→services. Vous choisissez combien de suggestions par couloir.

4 · Preuves réelles

Toujours réel, jamais simulé

Mode réel + strict uniquement. Chaque suggestion cite de vrais liens de sources effectivement récupérés, plus un pourquoi-maintenant. Pas de sources signifie pas de fabrication — juste un avis clair.

5 · Révision

Score, sources, sélection

La page de révision affiche impact/preuves/adéquation/effort, priorité calculée, le pourquoi-maintenant, et les liens sources par carte. Cochez celles qui valent la peine d'être gardées.

6 · Renvoyer

Aller-retour vers la Boîte de réception

« Envoyer à Threlmark » écrit des fichiers de suggestion plats dans le dossier suggestions/ du projet ; la Boîte de réception de Threlmark les accepte dans la feuille de route. Choisissez un projet cible différent pour une promotion croisée.

Lecture seule sauf un dossier. IdeaClyst n'écrit jamais que dans le répertoire suggestions/ d'un projet Threlmark — jamais dans ses éléments, tableau, ou métadonnées. Les suggestions portent une provenance (type, pourquoi-maintenant, sources) qui transite intact à travers la Boîte de réception de Threlmark.

Les analyses persistent sous .ideaclyst/roadmap/<id>/ et la page actualise en direct, tout comme une session. La source de données et tout URL de base REST sont définis dans /settings ; voir les nouvelles variables dans Configuration. L'intelligence de feuille de route est soumise au mode comme le reste de la recherche — elle s'exécute en mode réel + strict et affiche uniquement des données réelles.

05Cycle de vie d'une requête

Depuis le moment où vous appuyez sur soumettre, voici le chemin exact — notez que le serveur répond avant que le conseil ait terminé :

#ÉtapeCe qui se passe
1SoumettreLe formulaire /new envoie un POST du brief d'idée vers /api/runs.
2Valider & créerTitre requis, idée ≥ 10 caractères, objectif doit être valide. Une session queued est écrite sur disque (run.json + IDEA.md).
3Déclencher & oublierLe serveur appelle void startRun(id) sans attendre et retourne { runId } avec un 201 immédiatement.
4RedirigerLe client navigue vers /runs/[runId].
5InterrogerLa page de session récupère GET /api/runs/[runId] toutes les 1,5 s, en re-rendant à mesure que les sorties se remplissent.
6DélibérerEn arrière-plan, l'orchestrateur exécute les étapes 1→5, réécrivant run.json après chacune.
7TerminerL'étape 5 est divisée en onglets, le statut devient completed (ou failed), et l'interrogation s'arrête.
// api/runs/route.ts — le transfert déclencher-et-oublier
const run = await createRun(input);
void startRun(run.id);              // PAS attendu — s'exécute en arrière-plan
return NextResponse.json({ runId: run.id }, { status: 201 });

06Mode simulation vs. CLI

Une seule variable d'environnement, IDEACLYST_AGENT_MODE, sélectionne le backend. L'orchestrateur et l'interface sont identiques dans les deux modes — seul agents/ se comporte différemment.

AspectSimulation (défaut)CLI
Activé parIDEACLYST_AGENT_MODE=mockIDEACLYST_AGENT_MODE=cli
Besoin de CLIs ?Non — s'exécute instantanément hors-ligneOui — claude & codex installés + connectés
Piloté parSession structurée + clé d'étape (invite ignorée)L'invite générée (session/étape ignorées)
SortieMarkdown déterministe, adapté à l'idéeVrai résultat du modèle
Utiliser pourDémos, travail sur l'interface, développement hors-ligneVrais dossiers de planification
!

Prérequis du mode CLI. Les deux binaires doivent être dans le PATH et authentifiés : claude --version et codex login status. IdeaClyst ne gère jamais les identifiants — il s'appuie entièrement sur la session locale de chaque CLI.

Comptez des minutes, pas des secondes. Un conseil complet en mode CLI représente cinq vrais appels de modèle — environ 50–80 s par étape, ~5–7 min de bout en bout. Le mode simulation se termine instantanément. Les variables d'environnement sont lues au démarrage du serveur, donc redémarrez le serveur de développement après avoir changé le mode, et notez que changer de mode ne recalcule pas les sessions existantes — commencez une nouvelle session.

Une session a-t-elle vraiment utilisé les vrais CLIs ? Ouvrez son PRODUCT_STRATEGY.md — une vraie sortie est spécifique à votre idée et référence votre pile / contraintes préférées, tandis qu'une sortie en simulation réutilise un modèle fixe (elle insère votre texte d'idée dans des formulations génériques comme « …pointe vers un flux de travail actuellement manuel, fragmenté, ou simplement toléré »).

07Fonctionnement des appels CLI

En mode CLI, chaque étape du conseil lance un vrai processus. Les deux backends utilisent des arguments en tableau + stdin (jamais une chaîne shell), donc une invite ne peut pas casser l'échappement ou injecter de la syntaxe shell, et tous deux appliquent un délai d'attente par appel (défaut 180 s).

Backend Claude

Sans -p / --print. Quand la sortie standard de claude n'est pas un TTY (ici c'est un pipe), le CLI s'exécute de manière non-interactive et affiche une réponse unique, puis se termine. Donc IdeaClyst envoie simplement l'invite sur stdin et lit stdout — aucun drapeau d'impression nécessaire. --tools "" en fait une complétion de texte pure (sans actions de fichiers agentiques), et il s'exécute dans le répertoire de session propre de l'idée (spawn cwd) :

// agents/claude.ts — s'exécute dans le répertoire propre de la session
claude --tools ""                  // invite sur stdin, stdout pipé (non-TTY)
       [--model <model>]            // optionnel IDEACLYST_CLAUDE_MODEL

Retourne la sortie standard nettoyée. Un binaire manquant (ENOENT), une sortie non-nulle sans sortie, ou une sortie vide rejettent chacun avec un message clair « revenir au mode simulation ».

Pourquoi pas de -p ? Le comportement non-interactif propre du CLI est déclenché par un stdout non-TTY, pas uniquement par le drapeau d'impression — donc supprimer -p (et le --output-format propre à -p) donne quand même une complétion en un seul coup. Chaque idée s'exécute dans son propre répertoire, reproduisant l'isolation de Codex.

Backend Codex

Exécute Codex de manière non-interactive, en lecture seule, dans un répertoire de travail temporaire jetable pour qu'il ne puisse pas toucher votre système de fichiers — nous voulons uniquement la complétion de texte :

// agents/codex.ts
codex exec --json --skip-git-repo-check --ephemeral \
  -s read-only --color never \
  -C <temp-dir> -o last-message.txt -    // invite sur stdin

Le message final propre est lu depuis le fichier de sortie -o ; le flux d'événements --json est analysé comme solution de repli (et pour faire remonter une erreur d'API propre). Le répertoire temporaire est toujours supprimé ensuite. Un IDEACLYST_CODEX_MODEL optionnel ajoute -m <model>, sinon il s'en remet à ~/.codex/config.toml.

08Modèle de données & stockage

IdeaClyst est local-first : il n'y a ni base de données ni état en mémoire. Chaque session est un répertoire, et run.json est l'unique source de vérité — l'orchestrateur le réécrit après chaque étape, l'API de polling le relit simplement.

Structure sur disque

.ideaclyst/ # IDEACLYST_DATA_DIR (défaut) ├─ runs/ └─ <runId>/ # slug préfixé par horodatage ├─ run.json # ← source unique de vérité ├─ IDEA.md # le brief, lisible par l'humain ├─ RESEARCH_FINDINGS.md # étape 0 (recherche web) ├─ RESEARCH_DOSSIER.json # preuves structurées ├─ RESEARCH_TOOLKIT.md # tous les outils de recherche ├─ COMPETITOR_MATRIX.md # comparaison concurrentielle ├─ OPPORTUNITY_MAP.md # zones d'opportunités ├─ VALIDATION_EXPERIMENTS.md # tests ancrés dans les sources ├─ DISTRIBUTION_PLAN.md # premiers canaux ├─ IDEA_GRAVEYARD.md # critères d'abandon ├─ MVP_SCOPE_NEGOTIATION.md # décisions de périmètre ├─ LANDING_PAGE_CRITIC.md # critique de page concurrente ├─ COMPETITOR_WATCH.md # référence de veille locale ├─ FOUNDER_BRIEF.md # brief fondateur concis ├─ PRODUCT_STRATEGY.md # étape 1 ├─ TECHNICAL_ARCHITECTURE.md # étape 2 ├─ CRITIQUES.md # étapes 3 + 4 combinées ├─ FINAL_PLAN.md # étape 5 └─ TRANSCRIPT.md # journal de tous les échanges └─ discoveries/ └─ <discoveryId>/ ├─ discovery.json # lecture de marché, candidats, rapports ├─ MARKET_READ.md # paysage de marché ├─ OPPORTUNITY_MAP.md # zones de levier ├─ CANDIDATES.md # idées classées └─ CANDIDATE_REPORTS.md # rapports d'idées complets

L'enregistrement de session

Une session contient le brief (titre, idée, objectif, client cible optionnel / contraintes / pile préférée), un status de queued → running → completed | failed, une étiquette currentStep lisible par l'humain pour l'interface, et un objet outputs qui commence vide et se remplit. Les identifiants de session sont des slugs préfixés par horodatage, de sorte qu'un tri inversé de chaînes donne le plus récent en premier gratuitement.

StatutSignification
queuedCréé, conseil pas encore démarré.
runningConseil en cours ; currentStep indique où.
completedLes 5 étapes sont terminées ; onglets remplis.
failedUne étape a échoué ; error contient le message, les étapes précédentes sont préservées.

Division de sections tolérante. L'étape 5 demande des en-têtes ## exacts, mais markdown.ts les fait correspondre sans distinction de casse par mot-clé (ex. « mvp » / « backlog » / « scope ») et tolère ###. Si une section ne peut pas être trouvée, le plan complet revient dans l'onglet Résumé — un onglet n'est donc jamais vide.

09Référence API

GET /api/runs

Liste toutes les sessions, les plus récentes en premier. Retourne { runs: Run[] }.

POST /api/runs

Valide le brief, crée une session en file d'attente, déclenche le conseil en arrière-plan, et retourne { runId } (201). Validation : titre requis ; idée ≥ 10 caractères ; objectif ∈ validate · plan · build · pitch · refine.

// corps de la requête
{
  "title": "...",            // requis
  "idea": "...",             // requis, 10+ caractères
  "goal": "validate",        // requis, l'un des cinq
  "targetCustomer": "...",   // optionnel
  "constraints": "...",      // optionnel
  "preferredStack": "..."    // optionnel
}
GET /api/runs/[runId]

Retourne une session unique sous forme de { run: Run } — c'est ce que la page de détail interroge toutes les 1,5 s.

Piloter une session depuis le terminal

L'interface n'est qu'un client de cette API — tout ce que vous pouvez faire dans le navigateur, vous pouvez le faire depuis un script. Créez une session, interrogez-la jusqu'à ce qu'elle se termine, puis lisez le dossier sur disque :

# 1. Créer une session → retourne { "runId": "..." }
curl -s -X POST http://localhost:5417/api/runs \
  -H 'Content-Type: application/json' \
  -d '{"title":"StandupScribe","idea":"A Slack bot that posts a daily standup digest.","goal":"plan"}'

# 2. Interroger le statut jusqu'à complétion (toutes les quelques secondes)
curl -s http://localhost:5417/api/runs/<runId> | jq '.run.status, .run.currentStep'

# 3. Lire le dossier terminé
cat .ideaclyst/runs/<runId>/FINAL_PLAN.md

10Plan des fichiers

src/ ├─ app/ │ ├─ page.tsx # page d'accueil │ ├─ new/page.tsx # formulaire d'idée │ ├─ runs/page.tsx # liste des sessions │ ├─ runs/[runId]/page.tsx # détail de session en direct (interroge) │ └─ api/runs/ │ ├─ route.ts # GET liste / POST créer + déclencher │ └─ [runId]/route.ts # GET une session ├─ components/ # app-shell, idea-form, result-tabs,# run-card, status-pill, empty-state └─ lib/ ├─ agents/ # LE point de jonction de mode │ ├─ index.ts # dispatch runAgent() │ ├─ mock.ts # sortie hors-ligne adaptée à l'idée │ ├─ claude.ts # vrai `claude` (sans -p), répertoire par session │ ├─ codex.ts # vrai `codex exec` │ └─ prompts.ts # les 5 constructeurs d'invites ├─ runs/ │ ├─ types.ts # modèle de données Run / RunOutputs │ ├─ store.ts # lecture/écriture sur disque │ └─ markdown.ts # diviseur de sections du plan final ├─ orchestrator.ts # le pipeline en 5 étapes └─ utils.ts # slug/runId + rendu Markdown

11Configuration

Toute la configuration se trouve dans .env.local (copié depuis .env.example). Aucun secret n'est requis.

VariableDéfautRôle
IDEACLYST_AGENT_MODEmockmock ou cli
IDEACLYST_CLAUDE_BINclaudeBinaire / chemin du CLI Claude
IDEACLYST_CLAUDE_MODELvideModèle Claude concret (ex. opus), ou laisser au défaut du CLI
IDEACLYST_CODEX_BINcodexBinaire / chemin du CLI Codex
IDEACLYST_CODEX_MODELvideModèle Codex concret, ou laisser à ~/.codex/config.toml
IDEACLYST_AGENT_TIMEOUT_MS180000Délai d'attente par appel d'agent
IDEACLYST_DATA_DIR.ideaclystEmplacement de stockage des sessions

Recherche & découverte

Tout au mieux-effort ; le chemin réel nécessite une installation Chrome/Chromium. La recherche suit le mode agent sauf si elle est surchargée.

VariableDéfautRôle
IDEACLYST_RESEARCH_MODEsuit le mode agentSurcharge mock ou live
IDEACLYST_RESEARCH_STRICTdésactivé1 = ne jamais afficher de contenu simulé/hors-ligne ; afficher un avis clair si les données réelles sont indisponibles (à associer à live)
IDEACLYST_RESEARCH_ENGINEduckduckgoduckduckgo · bing · google
IDEACLYST_CHROME_BINauto-détectéSurcharge du chemin Chrome/Chromium
IDEACLYST_RESEARCH_USER_AGENTUA Chrome bureauSurcharge UA (évite les défis bot headless)
IDEACLYST_RESEARCH_CDP_PORT9222Port de débogage Chrome sans interface
IDEACLYST_RESEARCH_TIMEOUT_MS20000Délai de reconnaissance par page
IDEACLYST_RESEARCH_BUDGET_MS60000Budget total de recherche / étape scout
IDEACLYST_RESEARCH_MAX_RESULTS6Résultats de recherche analysés par requête
IDEACLYST_RESEARCH_MAX_SOURCES3Pages en reconnaissance approfondie
IDEACLYST_RESEARCH_IDLE_MS120000Fermer Chrome sans interface inactif après

Intelligence de feuille de route (Threlmark)

Indique à IdeaClyst d'où lire les projets Threlmark. La page /settings les modifie également ; les variables d'environnement ont la priorité.

VariableDéfautRôle
IDEACLYST_ROADMAP_SOURCEparamètres / disquedisk ou rest
THRELMARK_DATA_DIR~/.threlmarkRacine des données Threlmark (source disque)
IDEACLYST_ROADMAP_DIR= THRELMARK_DATA_DIRSurcharge de chemin explicite
IDEACLYST_THRELMARK_APIaucunURL de base pour la source REST (ex. http://localhost:5418)

12Lancer l'application

# démarrage rapide — mode simulation, aucun CLI requis
npm install
cp .env.example .env.local
npm run dev          # → http://localhost:5417

# ensuite : ouvrir l'app → « Démarrer une session d'idée » → soumettre → observer l'assemblage
ScriptAction
npm run devServeur de développement sur :5417 (Turbopack)
npm run buildBuild de production
npm run startServir le build de production sur :5417
npm run lintESLint
npm run typechecktsc --noEmit

13Limites & résolution de problèmes

!

Le rechargement à chaud interrompt les sessions en cours. L'orchestrateur s'exécute dans le même processus. En développement, modifier un fichier en cours de session peut tuer un conseil actif. Redémarrez dev et commencez une nouvelle session. Les étapes déjà terminées sur disque sont conservées.

!

« La session du conseil a échoué » en mode CLI. Presque toujours un CLI non installé ou non connecté. Vérifiez claude --version et codex login status, ou définissez IDEACLYST_AGENT_MODE=mock pour revenir aux sorties simulées.

!

Périmètre v0. Pas d'authentification, facturation, équipes, base de données, ou Docker. Les sessions sont des fichiers locaux. C'est intentionnel — IdeaClyst est un instrument de planification local-first, pas un produit hébergé.