brainclaw 1.22.0 → 1.24.0

package/dist/commands/mcp-write-coordination.js

@@ -22,7 +22,7 @@ import { validateMcpField } from '../core/input-validation.js';
 import { generateCandidateIdWithLabel, saveCandidate } from '../core/candidates.js';
 import { validateLoopProjectResolution } from '../core/loops/project-resolution.js';
 import { coordinateNextActions, dispatchNextActions } from '../core/next-actions.js';
-import { agentValidationFailedWarning, planAlreadyAssignedWarning, pushStructuredWarning, scopeAlreadyClaimedWarning, } from '../core/warnings.js';
+import { agentValidationFailedWarning, consultAutoExecuteNoOpWarning, planAlreadyAssignedWarning, pushStructuredWarning, scopeAlreadyClaimedWarning, } from '../core/warnings.js';
 import { ackMessage, getThread, hasActiveAssignment, sendMessage } from '../core/messaging.js';
 import { dispatch, dispatchReview, generateDispatchBrief } from '../core/dispatcher.js';
 import { CoordinateRequestSchema } from '../core/facade-schema.js';
@@ -847,7 +847,10 @@ export async function handleBclawCoordinate(args, ctx) {
         // the target inbox(es) and never spawns. autoExecute is a no-op here, so
         // say so explicitly rather than silently ignoring a caller who set it.
         if (req.autoExecute === true) {
-            warnings.push("autoExecute has no effect on intent='consult': consult delivers the RFC to the target inbox(es) only and never spawns an agent — targets pick it up via their own bclaw_work. For real spawning use bclaw_dispatch(intent='execute') on a sequence, or intent='assign'/'review' (pln#626).");
+            // pln#626 phase 3 — le refus passe desormais par le canal STRUCTURE. Un texte libre
+            // vaut mieux que le silence, mais un agent ne peut pas brancher dessus ; un code
+            // le peut, et la next_action nomme les deux chemins qui spawnent vraiment.
+            pushStructuredWarning(warnings, warningDetails, consultAutoExecuteNoOpWarning());
         }
         const consultThreadId = req.threadId ?? `thread_${crypto.randomBytes(4).toString('hex')}`;
         const contacted = [];
@@ -1972,11 +1975,17 @@ export async function handleBclawLoop(args, ctx) {
             response: createToolErrorResponse('intent_not_exposed', "bclaw_loop(intent='open') is not exposed standalone: it creates a loop structure without dispatching any turn, so the work never starts. Use bclaw_coordinate(intent='review', open_loop=true, targetAgents=[…]) or bclaw_coordinate(intent='ideate') — they open the loop AND dispatch the first turn."),
         };
     }
-    // pln#562 step 4 — dispatching a turn hands work to another agent; gate
-    // it at the same trust bar as the other dispatch surfaces.
-    // pln#632 — `bind` also SPAWNS real workers (it dispatches the loop's linked
-    // sequence), so it is gated at the same 'trusted' bar as turn-dispatch / coordinate.
-    if ((args?.intent === 'turn' && args?.dispatch === true) || args?.intent === 'bind') {
+    // pln#632 — `bind` SPAWNE de vrais workers (il dispatche la séquence liée de la
+    // boucle), donc il est protégé au barreau 'trusted' comme les autres surfaces de
+    // dispatch.
+    //
+    // LA BRANCHE `turn && dispatch === true` A ÉTÉ RETIRÉE (pln#626 phase 4). Le drapeau
+    // `TurnInput.dispatch` était déclaré, transporté jusqu'à `turn()` — et JAMAIS LU. Une
+    // porte de confiance sur un no-op est pire qu'absente : elle fait croire qu'un chemin
+    // sensible est gardé, et un lecteur qui la voit conclut à tort que `dispatch: true` a
+    // un effet. Le drapeau lui-même est supprimé dans le même commit ; garder la porte
+    // aurait laissé la fausse impression intacte.
+    if (args?.intent === 'bind') {
         const resolved = ensureTrust(args, { nameField: 'agent', idField: 'agentId' }, 'trusted', cwd, connectionSessionId);
         if (resolved.error) {
             return { response: createToolErrorResponse(resolved.error.kind, resolved.error.message, resolved.error.details) };

package/dist/commands/mcp.js

@@ -1026,6 +1026,50 @@ function resolveWorkspaceAnchor(cwd) {
 }
 // Read handlers moved to mcp-read-handlers.ts
 import { handleMcpReadToolCall } from './mcp-read-handlers.js';
+/**
+ * Projection COMPACTE de `open_work` (pln#598 etape 2).
+ *
+ * POURQUOI TRONQUER LA DESCRIPTION, et pourquoi ICI seulement. Une description
+ * d'assignation porte le BRIEF COMPLET du worker : mesure sur ce depot, des briefs de
+ * dispatch a plus de 1 500 caracteres, plusieurs a la fois dans open_work. Servis en
+ * entier dans une reponse dite « compacte », ils en font l'essentiel du poids — pour un
+ * texte que l'appelant a ecrit lui-meme et peut relire a la demande.
+ *
+ * La troncature vit dans la BRANCHE COMPACTE et non dans context.ts : les autres
+ * consommateurs de `open_work` — session-end, le board, les surfaces de diagnostic —
+ * ont besoin du texte entier, et le tronquer a la source leur retirerait sans le dire.
+ *
+ * LE TEXTE N'EST PAS PERDU, il est DIFFERE : chaque entree tronquee porte de quoi le
+ * recuperer. Un allegement qui supprime l'information au lieu de la deplacer n'allege
+ * rien — il deplace le probleme sur l'appelant, qui devine au lieu de lire.
+ */
+const OPEN_WORK_DESCRIPTION_LIMIT = 200;
+function compactOpenWork(openWork) {
+    if (!openWork || typeof openWork !== 'object')
+        return openWork ?? null;
+    const source = openWork;
+    if (!Array.isArray(source.active_assignments))
+        return openWork;
+    return {
+        ...source,
+        active_assignments: source.active_assignments.map((assignment) => {
+            const description = assignment['description'];
+            if (typeof description !== 'string' || description.length <= OPEN_WORK_DESCRIPTION_LIMIT) {
+                return assignment;
+            }
+            return {
+                ...assignment,
+                description: `${description.slice(0, OPEN_WORK_DESCRIPTION_LIMIT)}…`,
+                description_truncated: true,
+                // La suite EXACTE, pas une invitation vague : l'agent doit pouvoir la rejouer
+                // telle quelle. C'est la regle de src/core/next-actions.ts — une action qui ne
+                // decoule pas de ce qui s'est passe est du bruit ; celle-ci decoule de la
+                // troncature qu'on vient d'appliquer.
+                full_text_via: { tool: 'bclaw_get', args: { entity: 'assignment', id: assignment['id'] } },
+            };
+        }),
+    };
+}
 export { handleMcpReadToolCall };
 async function _executeMcpToolCallInner(payload) {
     const { name, args, cwd, connectionSessionId } = payload;
@@ -1430,7 +1474,7 @@ async function _executeMcpToolCallInner(payload) {
                     workflow_hints: hintsPool.slice(0, 3),
                     ...(hintsAggregate ? { workflow_hints_aggregate: hintsAggregate } : {}),
                     claim_conflicts: contextResult.claim_conflicts ?? [],
-                    open_work: contextResult.open_work ?? null,
+                    open_work: compactOpenWork(contextResult.open_work),
                     _compact: true,
                     _full_context_hint: 'Use bclaw_context(kind="memory") for the full payload.',
                 };

package/dist/commands/memory-confirm.js

@@ -0,0 +1,83 @@
+/**
+ * `brainclaw confirm` — attester ou infirmer l'applicabilité d'un item de mémoire
+ * (pln#620 étapes 2 et 3).
+ *
+ * ── POURQUOI CETTE COMMANDE EXISTE ────────────────────────────────────────────
+ * `recordMemoryEvent` était déjà écrit, testé, et branché sur un schéma
+ * (`MemoryConfirmationEvent`) porté par les traps, décisions et contraintes. Il n'était
+ * appelé DEPUIS NULLE PART. Mesuré au moment du correctif : 0 item sur 471 portait la
+ * moindre confirmation.
+ *
+ * C'est exactement la classe de défaut que trp#1292 décrit — un cœur vert et une
+ * fonctionnalité inerte, parce que rien ne la tire depuis une surface qu'un agent ou un
+ * opérateur appelle réellement.
+ *
+ * ── CE QUE ÇA CHANGE POUR LA PRIORISATION ─────────────────────────────────────
+ * Une mémoire non vérifiée ne peut pas justifier une priorité P0. Un trap écrit en mars,
+ * jamais reconfirmé, décrit peut-être un code qui n'existe plus — la démolition de la
+ * fédération v1 en a périmé plusieurs d'un coup. Sans trace d'applicabilité, on ne peut
+ * pas distinguer « toujours vrai » de « personne n'a revérifié depuis six mois ».
+ *
+ * L'ÉVIDENCE EST OBLIGATOIRE POUR CONFIRMER, et c'est le cœur du dispositif. Une
+ * confirmation sans preuve — un fichier:ligne, un sha, une sortie de commande — ne serait
+ * qu'une opinion horodatée, et deux opinions ne valent pas mieux qu'une. Infirmer, en
+ * revanche, ne l'exige pas : constater qu'un symbole a disparu est en soi la preuve.
+ */
+import { recordMemoryEvent } from '../core/memory-lifecycle.js';
+import { resolveEffectiveCwd } from '../core/store-resolution.js';
+import { resolveCurrentAgentName } from '../core/agent-registry.js';
+const ENTITIES = ['trap', 'decision', 'constraint'];
+const KINDS = ['confirm', 'infirm', 'saved_me', 'misled_me'];
+export function runMemoryConfirm(options) {
+    const entity = options.entity;
+    if (!ENTITIES.includes(entity)) {
+        console.error(`Entité inconnue '${options.entity}'. Attendu : ${ENTITIES.join(', ')}.`);
+        process.exitCode = 1;
+        return;
+    }
+    const kind = options.kind;
+    if (!KINDS.includes(kind)) {
+        console.error(`Type inconnu '${options.kind}'. Attendu : ${KINDS.join(', ')}.`);
+        process.exitCode = 1;
+        return;
+    }
+    // CONFIRMER SANS PREUVE EST REFUSÉ. Le but de ce dispositif est qu'une priorité puisse
+    // s'appuyer sur une vérification ; une attestation sans pointeur vers ce qui a été
+    // vérifié ne porte aucune information de plus que la date.
+    if (kind === 'confirm' && !options.evidence) {
+        console.error("Une confirmation exige --evidence : un fichier:ligne, un sha de commit, ou une sortie de commande.\n"
+            + "Sans preuve, l'attestation n'est qu'une opinion horodatée et ne peut pas justifier une priorité.");
+        process.exitCode = 1;
+        return;
+    }
+    const cwd = options.cwd ?? resolveEffectiveCwd();
+    const by = resolveCurrentAgentName(cwd);
+    let result;
+    try {
+        result = recordMemoryEvent({
+            entity, id: options.id, kind, by,
+            evidence: options.evidence,
+            note: options.note,
+            cwd,
+        });
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+        return;
+    }
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`✔ ${result.entity} ${result.id} — ${result.kind} par ${by}`);
+    if (options.evidence)
+        console.log(`  preuve : ${options.evidence}`);
+    console.log(`  confirmations : ${result.confirmation_count} · infirmations : ${result.infirmation_count}`
+        + ` · a servi : ${result.saved_me_count} · a induit en erreur : ${result.misled_me_count}`);
+    if (result.last_confirmed_at)
+        console.log(`  dernière confirmation : ${result.last_confirmed_at}`);
+    if (result.last_infirmed_at)
+        console.log(`  dernière infirmation  : ${result.last_infirmed_at}`);
+}
+//# sourceMappingURL=memory-confirm.js.map

package/dist/commands/switch.js

@@ -116,6 +116,7 @@ export function listAvailableProjectsForSession(cwd, sessionId) {
         : undefined;
     const projects = [];
     const seen = new Set();
+    const sessionDivergence = effective.session_divergence;
     const addProject = (project) => {
         const projectPath = path.resolve(project.path);
         if (seen.has(projectPath))
@@ -154,7 +155,12 @@ export function listAvailableProjectsForSession(cwd, sessionId) {
             relative_path: path.relative(wsRoot, linkPath) || '.',
         });
     }
-    return { workspace_root: wsRoot, active_source: activeSource, projects };
+    return {
+        workspace_root: wsRoot,
+        active_source: activeSource,
+        projects,
+        ...(sessionDivergence ? { session_divergence: sessionDivergence } : {}),
+    };
 }
 export function runSwitch(projectRef, options = {}) {
     // Use real cwd, not effective cwd — switch must see the full workspace
@@ -308,8 +314,12 @@ function showCurrent(wsRoot, cwd, json) {
     }
     const rel = path.relative(wsRoot, active.path) || '.';
     const switchedBy = 'switched_by' in active ? active.switched_by : undefined;
+    const divergence = effective.session_divergence;
     if (json) {
-        console.log(JSON.stringify({ active: true, ...active, relative_path: rel, scope: source }));
+        console.log(JSON.stringify({
+            active: true, ...active, relative_path: rel, scope: source,
+            ...(divergence ? { session_divergence: divergence } : {}),
+        }));
     }
     else {
         const scopeHint = source === 'session' ? ' (session-scoped)' : ' (global — all agents)';
@@ -317,6 +327,17 @@ function showCurrent(wsRoot, cwd, json) {
         console.log(`  switched at: ${active.switched_at}`);
         if (switchedBy)
             console.log(`  switched by: ${switchedBy}`);
+        if (divergence) {
+            // Le defaut d'origine n'etait pas qu'un lecteur se trompait : c'est que deux
+            // lecteurs pouvaient diverger EN SILENCE. Le dire est tout l'objet de ce bloc.
+            const label = divergence.session_project_name
+                ? `"${divergence.session_project_name}"`
+                : divergence.session_project_path;
+            console.log('');
+            console.log(`  ⚠ Divergence : un record de session designe ${label},`);
+            console.log(`    mais la resolution a retenu ce projet via '${divergence.resolved_via}'.`);
+            console.log(`    Les ecritures suivent la resolution, pas la session.`);
+        }
     }
 }
 function listProjects(wsRoot, cwd, json) {
@@ -328,6 +349,7 @@ function listProjects(wsRoot, cwd, json) {
             workspace: result.workspace_root,
             active_source: result.active_source,
             projects: result.projects,
+            ...(result.session_divergence ? { session_divergence: result.session_divergence } : {}),
         }, null, 2));
         return;
     }

package/dist/core/assignment-request-schema.js

@@ -0,0 +1,112 @@
+/**
+ * Schémas zod des entrées de la famille ASSIGNMENT — `bclaw_assignment_update`,
+ * `bclaw_assignment_action`, `bclaw_assignment_events` (pln#599 batch 2, cinquième famille).
+ *
+ * ── LA FAMILLE LA PLUS PROFONDE MIGRÉE JUSQU'ICI ──────────────────────────────
+ * `assignment_update` porte deux objets imbriqués qui ont LEURS PROPRES `required` :
+ * l'item d'`artifacts` (`type`+`ref`) et `action_required` (`kind`+`title`+`prompt`).
+ * Ces requis internes font partie du contrat publié et doivent survivre à la migration —
+ * c'est le pendant profond du piège de la famille séquence, où un requis de premier niveau
+ * était passé optionnel sans que rien d'autre que le fingerprint ne le voie.
+ *
+ * ── DEUX OBJETS DÉLIBÉRÉMENT LIBRES ───────────────────────────────────────────
+ * `payload` et `response_schema` sont publiés comme `{ type: 'object' }` NU : aucune
+ * propriété, aucune contrainte. Ce sont des sacs de données dont la forme appartient à
+ * l'appelant.
+ *
+ * Les quatre constructions candidates ont été MESURÉES, pas supposées :
+ *   z.object({})                        -> properties:{} + additionalProperties:false
+ *                                          (un objet qui n'accepte plus RIEN — le
+ *                                          durcissement le plus radical possible, sur les
+ *                                          deux champs les plus ouverts de la famille)
+ *   z.looseObject({})                   -> properties:{} + additionalProperties:{}
+ *   z.record(z.string(), z.unknown())   -> + propertyNames + additionalProperties
+ *   z.unknown().meta({ type:'object' }) -> { type: 'object' }  <- seul exact
+ * La comparaison à la version manuelle a rejeté les trois premiers.
+ *
+ * ── CE QUI GARDE SON ENUM, ET POURQUOI ────────────────────────────────────────
+ * `status`, `outcome` et `action_required.kind` en avaient déjà un dans la version
+ * manuelle : le leur retirer serait l'assouplissement symétrique du durcissement qu'on
+ * évite ailleurs. En revanche `artifacts[].type` et `eventType` restent des chaînes
+ * libres bien que leurs valeurs soient énumérées en description — les resserrer serait un
+ * rejet nouveau.
+ */
+import { z } from 'zod';
+/** Identité de l'appelant — commune à toutes les familles migrées. */
+const CallerIdentity = {
+    agent: z.string().describe('Agent name.').optional(),
+    agentId: z.string().describe('Registered agent id.').optional(),
+};
+/** Item d'artefact. `type` et `ref` sont REQUIS — requis IMBRIQUÉ, à préserver. */
+const ArtifactSchema = z.object({
+    type: z.string().describe('Artifact type: commit, branch, file, pr, test_result.'),
+    ref: z.string().describe('Reference: SHA, branch name, file path, PR URL.'),
+    description: z.string().describe('Optional description.').optional(),
+});
+/** ActionRequired. `kind`+`title`+`prompt` REQUIS — second requis imbriqué. */
+const ActionRequiredSchema = z
+    .object({
+    kind: z
+        .enum(['approval', 'user_input', 'clarification', 'plan_approval'])
+        .describe('Kind of action needed.'),
+    title: z.string().describe('Short title shown to supervisors/UI.'),
+    prompt: z.string().describe('Question or approval prompt to answer.'),
+    options: z.array(z.string()).describe('Optional answer choices.').optional(),
+    // Objet NU. Mesure des candidats plutôt que supposition :
+    //   z.object({})    -> properties:{} + additionalProperties:false  (n'accepte RIEN)
+    //   z.looseObject({}) -> properties:{} + additionalProperties:{}   (accepte, mais ajoute
+    //                        deux clés que la version publiée n'avait pas)
+    //   z.record(...)   -> ajoute propertyNames + additionalProperties
+    //   z.unknown().meta({ type: 'object' }) -> { type: 'object' } exactement.
+    // Seul le dernier reproduit la surface manuelle.
+    response_schema: z
+        .unknown()
+        .meta({ type: 'object' })
+        .describe('Optional structured response schema hint.')
+        .optional(),
+    tags: z.array(z.string()).describe('Optional tags.').optional(),
+})
+    .describe('Optional ActionRequired payload when status=blocked. Lets the worker request approval, user input, or clarification before resuming.');
+export const AssignmentUpdateRequestSchema = z.object({
+    assignment_id: z.string().describe('Assignment ID from the dispatch brief (asgn_xxx).'),
+    status: z
+        .enum(['accepted', 'started', 'progress', 'completed', 'failed', 'blocked'])
+        .describe('Lifecycle status to report.'),
+    message: z.string().describe('Human-readable status message or progress note.').optional(),
+    artifacts: z
+        .array(ArtifactSchema)
+        .describe('Artifacts produced. Most useful for completed status.')
+        .optional(),
+    error_message: z.string().describe('Error details (for failed status).').optional(),
+    blocker: z.string().describe('Blocker description (for blocked status).').optional(),
+    action_required: ActionRequiredSchema.optional(),
+    ...CallerIdentity,
+});
+export const AssignmentActionRequestSchema = z.object({
+    action_id: z.string().describe('ActionRequired ID (act_xxx).'),
+    outcome: z
+        .enum(['resolved', 'rejected', 'cancelled'])
+        .describe('How the supervisor resolves the pending action.'),
+    text: z.string().describe('Human-readable response or rationale.').optional(),
+    // Objet NU, même raison et même construction que response_schema.
+    payload: z
+        .unknown()
+        .meta({ type: 'object' })
+        .describe('Optional structured response payload.')
+        .optional(),
+    agent: z.string().describe('Supervisor/agent responding to the action.').optional(),
+    agentId: z.string().describe('Registered agent id.').optional(),
+});
+export const AssignmentEventsRequestSchema = z.object({
+    assignmentId: z.string().describe('Filter by linked assignment ID.').optional(),
+    runId: z.string().describe('Filter by linked run ID.').optional(),
+    claimId: z.string().describe('Filter by linked claim ID.').optional(),
+    sessionId: z.string().describe('Filter by runtime session ID.').optional(),
+    agent: z.string().describe('Filter by agent name.').optional(),
+    eventType: z.string().describe('Filter by runtime event type.').optional(),
+    id: z.string().describe('Get a single runtime event by ID.').optional(),
+    limit: z.number().describe('Maximum number of events to return (default: 20).').optional(),
+    offset: z.number().describe('Number of events to skip (for pagination).').optional(),
+    compact: z.boolean().describe('Return only key fields to reduce output size.').optional(),
+});
+//# sourceMappingURL=assignment-request-schema.js.map

package/dist/core/capture-schema.js

@@ -0,0 +1,62 @@
+/**
+ * Schémas zod des entrées de la famille CAPTURE — `bclaw_write_note` et
+ * `bclaw_quick_capture` (pln#599 batch 1, première famille).
+ *
+ * ── POURQUOI UNE FAMILLE ENTIÈRE, ET PAS TROIS OUTILS AU HASARD ───────────────
+ * Une source unique de vérité n'en est une que si elle couvre un ensemble COHÉRENT. Un
+ * catalogue à moitié dérivé double la maintenance — deux mécanismes à comprendre, deux
+ * endroits où corriger — sans donner le bénéfice, qui est de ne plus pouvoir faire
+ * diverger le schéma publié de la validation réelle. Le découpage par famille garantit
+ * qu'aucune surface ne reste à cheval sur les deux.
+ *
+ * ── LA CONTRAINTE QUI GOUVERNE CE FICHIER : FINGERPRINT INCHANGÉ ──────────────
+ * Le JSON Schema dérivé de ces objets doit être IDENTIQUE à celui écrit à la main qu'il
+ * remplace. Un champ optionnel devenu requis, un `enum` perdu, une `description`
+ * reformulée : chacun est une modification de la surface publique que des agents ont déjà
+ * apprise. La migration doit être invisible côté fil ; c'est ce que le test de parité
+ * vérifie.
+ *
+ * D'où des choix qui paraîtraient étranges hors de ce contexte — `visibility` reste une
+ * chaîne libre et non un enum, `crossProject` et `cross_project` coexistent. Ce ne sont
+ * pas des approximations : ce sont les schémas ACTUELS, et les resserrer ici mélangerait
+ * une migration mécanique avec un changement de contrat.
+ */
+import { z } from 'zod';
+/** Identité de l'appelant — présente à l'identique sur les deux outils de la famille. */
+const CallerIdentity = {
+    agent: z.string().describe('Agent name.').optional(),
+    agentId: z.string().describe('Registered agent id.').optional(),
+};
+export const WriteNoteRequestSchema = z.object({
+    text: z.string().describe('Note content.'),
+    ...CallerIdentity,
+    tags: z.array(z.string()).describe('Optional tags.').optional(),
+    // Chaîne libre et NON un enum : c'est l'état actuel du schéma publié. Le resserrer
+    // serait un changement de contrat déguisé en migration.
+    visibility: z.string().describe('Visibility: shared, machine, private.').optional(),
+    ttl: z.string().describe('Optional TTL: 30m, 2h, 7d.').optional(),
+    autoReflect: z
+        .boolean()
+        .describe('Attempt to reflect the runtime note into durable memory immediately.')
+        .optional(),
+    crossProject: z
+        .string()
+        .describe('Push note to a linked project (name or path). Requires role: publisher in cross_project_links config.')
+        .optional(),
+    // L'alias snake_case coexiste avec le camelCase. Le retirer casserait les appelants qui
+    // l'utilisent ; la migration ne doit rien retirer.
+    cross_project: z.string().describe('Snake_case alias of crossProject.').optional(),
+});
+export const QuickCaptureRequestSchema = z.object({
+    text: z.string().describe('Free-form capture text.'),
+    type: z
+        .enum(['decision', 'trap', 'constraint', 'note'])
+        .describe('Caller-asserted classification. Strongly recommended — the calling agent knows the nature of the capture better than keyword heuristics (cnd_abe61d68: 18 false contradiction positives on a review summary).')
+        .optional(),
+    context: z
+        .string()
+        .describe('Optional file/path/scope context to associate with the capture.')
+        .optional(),
+    ...CallerIdentity,
+});
+//# sourceMappingURL=capture-schema.js.map

package/dist/core/claim-request-schema.js

@@ -0,0 +1,72 @@
+/**
+ * Schémas zod des entrées de la famille CLAIM — `bclaw_claim` et `bclaw_release_claim`
+ * (pln#599 batch 2, deuxième famille composite).
+ *
+ * ── CONTRAINTE, INCHANGÉE DEPUIS LA FAMILLE CAPTURE ───────────────────────────
+ * Le JSON Schema produit doit être byte-identique à celui écrit à la main : le fingerprint
+ * de gouvernance (tests/unit/mcp-governance.test.ts) ne doit pas bouger. Une migration qui
+ * déplace le fingerprint n'est plus une migration, c'est un changement de surface publique.
+ *
+ * ── LES DEUX PIÈGES PAYÉS COMPTANT SUR #220/#221, REPRODUITS ICI EN GARDE ──────
+ * 1. zod émet `additionalProperties: false` d'office. Le laisser DURCIT le contrat : un
+ *    client passant une clé inconnue était ACCEPTÉ (clé ignorée) et se ferait désormais
+ *    rejeter. Le générateur le retire — À LA RACINE UNIQUEMENT, cf. OPEN_SCHEMAS.
+ * 2. Un champ REQUIS dans la version manuelle doit le rester. `rank` était passé optionnel
+ *    par inadvertance sur la famille séquence : assouplissement du contrat, attrapé par le
+ *    seul fingerprint. Ici les requis sont `scope`+`description` (claim) et `id` (release).
+ *
+ * Ni l'un ni l'autre n'avait été vu par mes propres vérifications, ni par le snapshot du
+ * registre CLI — qui mesure quelque chose de plus faible et donne une fausse assurance.
+ *
+ * ── CE QUI N'EST PAS RESSERRÉ, DÉLIBÉRÉMENT ───────────────────────────────────
+ * `store` et `planStatus` restent des chaînes libres et non des enums, bien que leurs
+ * valeurs utiles soient énumérées dans leur description. Les resserrer mérite sa propre
+ * décision : ce serait un rejet nouveau sur des appels aujourd'hui acceptés.
+ * `handoffMode` garde en revanche son enum, parce qu'il en avait DÉJÀ un.
+ */
+import { z } from 'zod';
+/** Identité de l'appelant — commune à la famille, comme pour capture et séquence. */
+const CallerIdentity = {
+    agent: z.string().describe('Agent or person name.').optional(),
+    agentId: z.string().describe('Registered agent id.').optional(),
+};
+export const ClaimRequestSchema = z.object({
+    scope: z.string().describe('Scope being claimed.'),
+    description: z.string().describe('Description of the work.'),
+    ...CallerIdentity,
+    planId: z.string().describe('Optional linked plan item ID.').optional(),
+    project: z
+        .string()
+        .describe('Project name or path. Use this when working on a project different from the MCP server workspace (e.g. CLI agents in a different directory).')
+        .optional(),
+    // Chaîne libre, PAS un enum : les trois niveaux sont documentés mais la valeur reste
+    // ouverte côté schéma publié.
+    store: z.string().describe('Target store level: local (default), repo, workspace.').optional(),
+    worktreeBranch: z
+        .string()
+        .describe('Branch name for the worktree. Defaults to feat/<scope-slug>.')
+        .optional(),
+    worktree: z
+        .boolean()
+        .describe('Whether to create an isolated git worktree (default true). Pass false for an advisory-only lock with no worktree (trp#431) — for in-place work in the main tree.')
+        .optional(),
+    advisory: z
+        .boolean()
+        .describe('Alias for worktree:false — advisory-only lock with no worktree (trp#431).')
+        .optional(),
+    // Enum CONSERVÉ : il existait déjà dans le schéma manuel. Le retirer serait
+    // l'assouplissement symétrique du durcissement qu'on évite ailleurs.
+    handoffMode: z
+        .enum(['self-commit', 'integrator'])
+        .describe('Handoff mode: "self-commit" (worker commits+merges) or "integrator" (another agent reviews+merges). Default: self-commit.')
+        .optional(),
+});
+export const ReleaseClaimRequestSchema = z.object({
+    id: z.string().describe('Claim ID to release.'),
+    planStatus: z.string().describe('Optional: update linked plan status.').optional(),
+    coordinator_override: z
+        .boolean()
+        .describe('Opt-in override for a trusted+ caller releasing a claim they do NOT own (cross-agent teardown, ghost-claim cleanup). Rejected for contributor-level callers; audited when used. trp#928.')
+        .optional(),
+});
+//# sourceMappingURL=claim-request-schema.js.map

package/dist/core/code-map/aggregate.js

@@ -468,6 +468,41 @@ export function aggregateBrief(target, limit, resolved, currentHead, memoryReade
         ...(capped[i].cross_package ? { cross_package: true } : {}),
         ...(capped[i].local ? { local: true } : {}),
     }));
-    return { target, suggested_files_to_read: suggested, related_memory: related, freshness_badge: mergeBadges(perStore.map((p) => ({ ref: p.ref, badge: p.badge, hasIndex: p.r.hasIndex }))) };
+    return {
+        target,
+        suggested_files_to_read: suggested,
+        related_memory: summarizeRelatedMemory(related),
+        freshness_badge: mergeBadges(perStore.map((p) => ({ ref: p.ref, badge: p.badge, hasIndex: p.r.hasIndex }))),
+    };
+}
+/**
+ * Resume la memoire liee servie par `code_brief` (pln#598 etape 3).
+ *
+ * POURQUOI. Un trap ou une decision de ce depot depasse regulierement 2 000 caracteres —
+ * plusieurs des textes ecrits pendant la refonte federation v2 en font le double. Un
+ * `code_brief` qui attache trois d'entre eux sert des milliers de caracteres avant meme
+ * que l'agent n'ait ouvert un fichier, pour un contenu qu'il ne lira peut-etre pas.
+ *
+ * LE TEXTE N'EST PAS PERDU, IL EST DIFFERE. Chaque entree raccourcie porte l'appel EXACT
+ * qui rend l'integralite. Un allegement qui supprime l'information au lieu de la deplacer
+ * force l'agent a deviner — et deviner sur un trap est precisement ce que les traps
+ * existent pour eviter.
+ *
+ * `id`, `kind`, `tags` et `related_paths` restent ENTIERS : ce sont eux qui permettent de
+ * decider s'il vaut la peine d'aller lire. Les tronquer ferait economiser des octets sur
+ * la seule partie qui sert a trier.
+ */
+const RELATED_MEMORY_TEXT_LIMIT = 300;
+export function summarizeRelatedMemory(items) {
+    return items.map((item) => {
+        if (typeof item.text !== 'string' || item.text.length <= RELATED_MEMORY_TEXT_LIMIT)
+            return item;
+        return {
+            ...item,
+            text: `${item.text.slice(0, RELATED_MEMORY_TEXT_LIMIT)}…`,
+            text_truncated: true,
+            full_text_via: { tool: 'bclaw_get', args: { entity: item.kind, id: item.id } },
+        };
+    });
 }
 //# sourceMappingURL=aggregate.js.map