@ignitionai/cogitator 0.4.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,460 @@
1
+ /**
2
+ * Runtime de mission durable (Plan 0002 §5, ADR-008 D2/D3/D4/D6/D7) — la SEULE
3
+ * implémentation d'exécution Durable du produit, atteinte par le point de
4
+ * composition explicite `src/runtime.ts`. Aucun autre code ne doit ouvrir un
5
+ * stockage Durable ou lancer un harnais : pas de processus non gérés.
6
+ *
7
+ * Garanties à l'ouverture (Plan 0002 §8.2) :
8
+ * 1. bail d'exécution OS-acquis avant l'ouverture du stockage ; un second
9
+ * processus sort sans rien planifier ;
10
+ * 2. stockage SQLite en `synchronous = FULL` (le défaut du SDK est NORMAL) ;
11
+ * 3. profil de mission gelé vérifié (SDK pin, snapshot preset, toolchain) —
12
+ * toute divergence rejette l'ouverture (fail closed) ;
13
+ * 4. workers orphelins classés (vivant → orphelin à observer/arrêter ; mort
14
+ * sans disposition → issue inconnue) avant d'activer la planification ;
15
+ * 5. la planification Durable n'est activée qu'après ces vérifications.
16
+ *
17
+ * Admission (P3b, ticket #16) : les envois sont acceptés durablement, mais ne
18
+ * sont dispatchés que si la mission est admise (budget + slot + claim
19
+ * workspace). Sinon l'input reste dans une file durable et VISIBLE (queued /
20
+ * budget_paused — jamais d'échec d'envoi ni de travail caché). Approbations et
21
+ * receipts vivent ici (vérité Durable, D4) ; le dispatch d'un effet protégé
22
+ * passe par `runProtectedEffect` (consommation de grant + association d'intent
23
+ * atomiques, scope exact rechecké immédiatement avant l'effet).
24
+ */
25
+ import { BACKGROUND_CONTEXT as context } from "@earendil-works/chord/context";
26
+ import { defineDoc, Harness, UsageDoc, watchEvents, } from "@earendil-works/pi-durable";
27
+ import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
28
+ import { SqliteStorage } from "@earendil-works/pi-durable/storage/sqlite";
29
+ import { openNodeSqliteDatabase } from "@earendil-works/pi-durable/storage/sqlite/node";
30
+ import { join } from "node:path";
31
+ import { acquireRuntimeLease } from "./lease.js";
32
+ import { MissionProfile, freezeMissionProfile, assertProfileFrozen } from "./profile.js";
33
+ import { WorkerRecords, classifyWorkers, unresolvedWorkers } from "./workers.js";
34
+ import { MissionApprovals, GrantRejectedError, createPendingAction, decidePendingAction, findValidGrant, revokeGrant, } from "./approvals.js";
35
+ import { dailyUsage, evaluateBudget, rollDailyBaseline, } from "./admission.js";
36
+ /** requestId borné et stable (caractères sûrs, 1–128). Miroir de schemas.ts. */
37
+ export const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
38
+ export class NeedsAttentionError extends Error {
39
+ constructor(message) {
40
+ super(message);
41
+ this.name = "NeedsAttentionError";
42
+ }
43
+ }
44
+ export { GrantRejectedError };
45
+ const MissionQueue = defineDoc({
46
+ kind: "cogitator.mission-queue",
47
+ version: 1,
48
+ scope: "conversation",
49
+ history: "latest",
50
+ fork: "initial",
51
+ initial: () => ({ inputs: [] }),
52
+ });
53
+ const MissionBudget = defineDoc({
54
+ kind: "cogitator.mission-budget",
55
+ version: 1,
56
+ scope: "conversation",
57
+ history: "latest",
58
+ fork: "initial",
59
+ initial: () => ({ policy: {}, missionCalls: 0, missionTokens: 0, baseline: { day: "", calls: 0, tokens: 0 }, updatedAt: 0 }),
60
+ });
61
+ /** Plan de contrôle par défaut : pas d'admission (dispatch immédiat). */
62
+ const PERMISSIVE_CONTROL = {
63
+ workspaceDir: "",
64
+ tryAdmit: () => ({ admitted: true }),
65
+ release: () => undefined,
66
+ claimHolder: () => undefined,
67
+ emit: () => undefined,
68
+ };
69
+ export class DurableMissionRuntime {
70
+ harness;
71
+ root;
72
+ lease;
73
+ registry;
74
+ control;
75
+ recovery;
76
+ /** Écritures en cours (turns dispatchés) : le claim se relâche à zéro. */
77
+ activeWrites = 0;
78
+ draining = false;
79
+ closed = false;
80
+ constructor(harness, root, lease, registry, control,
81
+ /** État de récupération à l'ouverture (workers orphelins classés). */
82
+ recovery) {
83
+ this.harness = harness;
84
+ this.root = root;
85
+ this.lease = lease;
86
+ this.registry = registry;
87
+ this.control = control;
88
+ this.recovery = recovery;
89
+ }
90
+ static async open(opts) {
91
+ const lease = acquireRuntimeLease(opts.dir);
92
+ try {
93
+ // FULL = durability exigée par le déploiement (constat P0 : le défaut est NORMAL).
94
+ const database = await openNodeSqliteDatabase(join(opts.dir, "runtime.sqlite"));
95
+ await database.exec("PRAGMA synchronous = FULL");
96
+ const storage = await SqliteStorage.open(database);
97
+ const installedExtensions = opts.registry.snapshot().installed().map((e) => e.name);
98
+ const versions = freezeMissionProfile(opts.presetDigest, {
99
+ commands: [...opts.toolchain.commands].sort(),
100
+ mcpServers: [...opts.toolchain.mcpServers].sort(),
101
+ extensions: [...installedExtensions].sort(),
102
+ });
103
+ const harness = await Harness.open(storage, {
104
+ models: opts.models,
105
+ registry: opts.registry,
106
+ env: () => new NodeExecutionEnv({ cwd: opts.cwd }),
107
+ // Profil figé du seam (constat P0) : pas de retry implicite — la politique
108
+ // de retry budgétée des missions est une slice P3 ultérieure ; la compaction
109
+ // n'a pas de politique de mission à ce stade.
110
+ settings: { compaction: { enabled: false }, retry: { enabled: false } },
111
+ }, context);
112
+ const root = await harness.root(context, {
113
+ agent: { extensions: opts.agentExtensions, model: opts.model },
114
+ // Gel à la création uniquement : sur réouverture le document existe et n'est pas écrasé.
115
+ init: async (tx, id) => {
116
+ const doc = await tx.doc(MissionProfile, id);
117
+ if (!doc.createdAt)
118
+ Object.assign(doc, { ...versions, createdAt: Date.now() });
119
+ },
120
+ });
121
+ const runtime = new DurableMissionRuntime(harness, root, lease, opts.registry, opts.control ?? PERMISSIVE_CONTROL, {
122
+ workers: [],
123
+ needsAttention: false,
124
+ reasons: [],
125
+ });
126
+ await runtime.verifyFrozenProfile(versions);
127
+ await runtime.reconcileWorkers();
128
+ // Planification activée seulement après vérification bail/versions/état ;
129
+ // si un orphelin n'est pas classé, la readiness reste fausse (Plan 0002 §8.2).
130
+ if (!runtime.recovery.needsAttention)
131
+ harness.resume();
132
+ // Reprise : les inputs retenus en file (slots/budget à l'ancienne session)
133
+ // restent durables ; on retente l'admission maintenant que la runtime est ouverte.
134
+ void runtime.tryDrainQueue();
135
+ return runtime;
136
+ }
137
+ catch (err) {
138
+ lease.release();
139
+ throw err;
140
+ }
141
+ }
142
+ /** Preflight fail-closed : profil gelé (stockage Durable) vs versions installées. */
143
+ async verifyFrozenProfile(expected) {
144
+ const stored = await this.harness.snapshot(MissionProfile, this.root.id, context);
145
+ const installed = this.registry.snapshot().installed().map((e) => e.name);
146
+ assertProfileFrozen(stored ? { ...stored } : undefined, expected, installed);
147
+ }
148
+ /** Reclasse les workers persistés (§5.7) et expose le résultat de récupération. */
149
+ async reconcileWorkers() {
150
+ const doc = await this.harness.snapshot(WorkerRecords, this.root.id, context);
151
+ const workers = classifyWorkers(doc?.workers ?? []);
152
+ const unresolved = unresolvedWorkers(workers);
153
+ this.recovery.workers = workers;
154
+ this.recovery.needsAttention = unresolved.length > 0;
155
+ this.recovery.reasons = unresolved.map((u) => u.kind === "live-orphan"
156
+ ? `worker ${u.record.id} (pid ${u.record.pid}) toujours vivant : observer/arrêter avant remplacement`
157
+ : `worker ${u.record.id} (pid ${u.record.pid}) mort sans issue établie : réconciliation requise`);
158
+ }
159
+ // ---------- File d'attente durable et admission ----------
160
+ async queuedInputs() {
161
+ const doc = await this.harness.snapshot(MissionQueue, this.root.id, context);
162
+ return doc?.inputs ?? [];
163
+ }
164
+ /** État budget courant : cumuls re-lus depuis le transcript et pi.usage, base journalière roulée à UTC. */
165
+ async budgetState(now = Date.now()) {
166
+ // Requêtes modèle = entrées d'assistant commitées (authoritative, indépendant
167
+ // du reporting d'usage du provider) ; tokens depuis pi.usage quand le provider
168
+ // les rapporte (sinon 0 — la limite tokens reste applicable dès qu'ils sont là).
169
+ const entries = (await this.root.context(context)).entries;
170
+ const calls = entries.filter((e) => e.kind === "pi.assistant").length;
171
+ const usage = (await this.harness.snapshot(UsageDoc, this.root.id, context)) ?? { models: {}, tools: {} };
172
+ let tokens = 0;
173
+ for (const modelUsage of Object.values(usage.models)) {
174
+ const u = modelUsage;
175
+ tokens += u?.totalTokens ?? 0;
176
+ }
177
+ const doc = await this.harness.snapshot(MissionBudget, this.root.id, context);
178
+ const policy = doc?.policy ?? {};
179
+ const missionUsed = { calls, tokens };
180
+ const baseline = rollDailyBaseline(doc?.baseline ?? { day: "", calls: 0, tokens: 0 }, missionUsed, now);
181
+ if (doc && (doc.missionCalls !== calls || doc.missionTokens !== tokens || doc.baseline.day !== baseline.day)) {
182
+ await this.root.commit(async (tx) => {
183
+ const d = await tx.doc(MissionBudget, this.root.id);
184
+ d.missionCalls = calls;
185
+ d.missionTokens = tokens;
186
+ d.baseline = baseline;
187
+ d.updatedAt = now;
188
+ }, context);
189
+ }
190
+ const dailyUsed = dailyUsage(baseline, missionUsed, now);
191
+ const evaluated = evaluateBudget(policy, missionUsed, dailyUsed, now);
192
+ return {
193
+ policy,
194
+ missionUsed,
195
+ dailyUsed,
196
+ ...(evaluated.status === "budget_paused" ? { binding: evaluated.binding } : {}),
197
+ };
198
+ }
199
+ /** Change EXPLICITEMENT la politique de budget (owner) ; relance la file si déliée. */
200
+ async setBudgetPolicy(policy) {
201
+ await this.root.commit(async (tx) => {
202
+ const doc = await tx.doc(MissionBudget, this.root.id);
203
+ doc.policy = policy;
204
+ doc.updatedAt = Date.now();
205
+ }, context);
206
+ this.control.emit(await this.missionStatus());
207
+ await this.tryDrainQueue();
208
+ }
209
+ /**
210
+ * Projection de statut de mission (authoritative, dérivée des documents
211
+ * durables : file, budget, approbations, workers). priorité :
212
+ * needs_attention > budget_paused > waiting_approval > queued > running/idle.
213
+ */
214
+ async missionStatus(now = Date.now()) {
215
+ const budget = await this.budgetState(now);
216
+ const queue = await this.queuedInputs();
217
+ const approvals = await this.approvalsView();
218
+ const holder = this.control.claimHolder();
219
+ const base = {
220
+ queueLength: queue.length,
221
+ budget,
222
+ workspaceDir: this.control.workspaceDir,
223
+ workspaceClaimed: holder !== undefined,
224
+ workspaceClaimedBy: holder,
225
+ };
226
+ if (this.recovery.needsAttention) {
227
+ return { state: "needs_attention", reason: this.recovery.reasons.join("; "), ...base };
228
+ }
229
+ const queueDoc = await this.harness.snapshot(MissionQueue, this.root.id, context);
230
+ if (queueDoc?.attention) {
231
+ return { state: "needs_attention", reason: queueDoc.attention.reason, ...base };
232
+ }
233
+ if (budget.binding) {
234
+ return { state: "budget_paused", reason: `limite ${budget.binding.kind} atteinte (${budget.binding.used}/${budget.binding.limit})`, ...base };
235
+ }
236
+ if (approvals.pendingActions.some((p) => p.decision === "pending")) {
237
+ return { state: "waiting_approval", reason: "action sensible en attente de décision owner", ...base };
238
+ }
239
+ if (queue.length > 0) {
240
+ const admission = this.control.tryAdmit();
241
+ return {
242
+ state: "queued",
243
+ ...(admission.admitted ? {} : { reason: admission.reason }),
244
+ ...base,
245
+ };
246
+ }
247
+ return { state: this.activeWrites > 0 ? "running" : "idle", ...base };
248
+ }
249
+ /**
250
+ * Retente la dispatch des inputs retenus : admission (budget → slot → claim),
251
+ * puis soumission IN ORDER au SDK. Un seul drain à la fois ; les arrivées
252
+ * pendant un drain se représentent au drain suivant.
253
+ */
254
+ async tryDrainQueue() {
255
+ if (this.draining || this.closed || this.recovery.needsAttention)
256
+ return;
257
+ this.draining = true;
258
+ try {
259
+ for (;;) {
260
+ if (this.closed)
261
+ break;
262
+ const queue = await this.queuedInputs();
263
+ if (queue.length === 0)
264
+ break;
265
+ const budget = await this.budgetState();
266
+ if (budget.binding)
267
+ break; // budget_paused : la file reste visible, aucun dispatch
268
+ const admission = this.control.tryAdmit();
269
+ if (!admission.admitted)
270
+ break;
271
+ const input = queue[0];
272
+ // Un échec de dispatch laisse l'input en tête de file : la tentative
273
+ // suivante le reprend (jamais de perte ni de duplication).
274
+ try {
275
+ await this.dispatch(input.text, input.requestId);
276
+ }
277
+ catch {
278
+ break;
279
+ }
280
+ await this.root.commit(async (tx) => {
281
+ const doc = await tx.doc(MissionQueue, this.root.id);
282
+ doc.inputs = doc.inputs.filter((i) => i.requestId !== input.requestId);
283
+ }, context);
284
+ }
285
+ }
286
+ catch (err) {
287
+ // La file durable conserve l'input : l'erreur (fermeture concurrente ou
288
+ // stockage) se représentera à la prochaine tentative ; un drain ne doit
289
+ // jamais rejeter vers des appelants fire-and-forget.
290
+ void err;
291
+ }
292
+ finally {
293
+ this.draining = false;
294
+ if (!this.closed) {
295
+ const status = await this.missionStatus().catch(() => null);
296
+ if (status)
297
+ this.control.emit(status);
298
+ }
299
+ }
300
+ }
301
+ /** Soumet une entrée utilisateur avec un requestId stable et borné. L'accusé
302
+ * n'est renvoyé qu'APRÈS l'acceptation durable. Un requestId déjà accepté ne
303
+ * duplique JAMAIS le travail. Si la mission n'est pas admise (budget/slots/
304
+ * claim), l'input est retenu dans la file durable et VISIBLE (l'envoi reste
305
+ * accepté : jamais d'échec invitant à une duplication accidentelle). */
306
+ async submit(text, requestId) {
307
+ if (!REQUEST_ID_PATTERN.test(requestId)) {
308
+ throw new Error(`requestId invalide (1–128, [A-Za-z0-9._-]): ${requestId}`);
309
+ }
310
+ const unresolved = unresolvedWorkers(this.recovery.workers);
311
+ if (unresolved.length > 0) {
312
+ // Pas de travail de remplacement tant qu'un worker orphelin n'est pas classé.
313
+ throw new NeedsAttentionError(this.recovery.reasons.join("; "));
314
+ }
315
+ const prior = await this.root.commit((tx) => tx.submissionByRequest(this.root.id, requestId), context);
316
+ if (prior)
317
+ return { submissionId: prior.id, duplicate: true, queued: false };
318
+ const queued = await this.queuedInputs();
319
+ if (queued.some((i) => i.requestId === requestId)) {
320
+ return { duplicate: true, queued: true };
321
+ }
322
+ // Admission : budget d'abord (budget_paused nomme la limite liante), puis
323
+ // slots + claim via le plan de contrôle. En écriture active, la mission
324
+ // détient déjà slot et claim : dispatch direct.
325
+ const budget = await this.budgetState();
326
+ if (budget.binding || this.activeWrites === 0) {
327
+ if (budget.binding || this.control.tryAdmit().admitted === false) {
328
+ await this.root.commit(async (tx) => {
329
+ const doc = await tx.doc(MissionQueue, this.root.id);
330
+ doc.inputs.push({ requestId, text, queuedAt: Date.now() });
331
+ }, context);
332
+ this.control.emit(await this.missionStatus());
333
+ void this.tryDrainQueue();
334
+ return { duplicate: false, queued: true };
335
+ }
336
+ }
337
+ const submissionId = await this.dispatch(text, requestId).catch((err) => {
338
+ // Dispatch impossible : on ne garde pas le slot/claim acquis pour rien.
339
+ this.control.release();
340
+ throw err;
341
+ });
342
+ return { submissionId, duplicate: false, queued: false };
343
+ }
344
+ /** Soumission effective au SDK + suivi d'écritures (relâchement à l'idle). */
345
+ async dispatch(text, requestId) {
346
+ const submission = await this.root.submit({ type: "input", content: text, requestId }, context);
347
+ // Un dispatch réussi lève toute condition de denégation antérieure.
348
+ await this.root.commit(async (tx) => {
349
+ const doc = await tx.doc(MissionQueue, this.root.id);
350
+ if (doc.attention)
351
+ delete doc.attention;
352
+ }, context);
353
+ this.trackWrites();
354
+ return submission.id;
355
+ }
356
+ /** Compte l'activité : le slot et le claim ne se relâchent qu'à l'arrêt des écritures. */
357
+ trackWrites() {
358
+ this.activeWrites += 1;
359
+ void this.root.waitForIdle(context)
360
+ .catch(() => undefined)
361
+ .finally(() => {
362
+ this.activeWrites -= 1;
363
+ if (this.activeWrites === 0) {
364
+ this.control.release();
365
+ void this.tryDrainQueue();
366
+ }
367
+ });
368
+ }
369
+ // ---------- Approbations (owner) et effets protégés ----------
370
+ /** Vue lectures des pending actions, grants et receipts (panneau owner). */
371
+ async approvalsView() {
372
+ const doc = await this.harness.snapshot(MissionApprovals, this.root.id, context);
373
+ return {
374
+ pendingActions: doc?.pendingActions ?? [],
375
+ grants: (doc?.grants ?? []).map((g) => ({
376
+ ...g,
377
+ valid: !("reason" in findValidGrant([g], g, Date.now())),
378
+ })),
379
+ receipts: doc?.receipts ?? [],
380
+ };
381
+ }
382
+ /**
383
+ * Crée côté SERVEUR une action en attente (immuables : opération, cible,
384
+ * digests artefact/arguments, expiration, uses). Le client ne peut approuver
385
+ * QUE ces actions-là. Une demande identique déjà pending/denied est réutilisée
386
+ * (jamais re-demandée en boucle, UA1).
387
+ */
388
+ async requestPendingAction(input) {
389
+ const action = await this.root.commit(async (tx) => {
390
+ const doc = await tx.doc(MissionApprovals, this.root.id);
391
+ return createPendingAction(doc, input, Date.now());
392
+ }, context);
393
+ this.control.emit(await this.missionStatus());
394
+ return action;
395
+ }
396
+ /** Décision owner (approve/deny) sur une action serveur ; denial durable (UA1). */
397
+ async decideApproval(pendingActionId, decision, denialReason) {
398
+ const result = await this.root.commit((tx) => tx.doc(MissionApprovals, this.root.id).then((doc) => decidePendingAction(doc, pendingActionId, decision, Date.now(), denialReason)), context);
399
+ if (result.kind === "decided" && decision === "denied") {
400
+ // Dénégation durable : la mission passe en needs_attention (reason
401
+ // action_denied) ; aucun effet ne court, rien n'est re-demandé (UA1).
402
+ await this.root.commit(async (tx) => {
403
+ const doc = await tx.doc(MissionQueue, this.root.id);
404
+ doc.attention = { reason: `action_denied: ${denialReason ?? "refus owner"}`, at: Date.now() };
405
+ }, context);
406
+ }
407
+ this.control.emit(await this.missionStatus());
408
+ return result;
409
+ }
410
+ /** Révocation : bloque les FUTURES dispatches (n'annule pas un effet accepté). */
411
+ async revokeGrant(grantId) {
412
+ const result = await this.root.commit((tx) => tx.doc(MissionApprovals, this.root.id).then((doc) => revokeGrant(doc, grantId)), context);
413
+ this.control.emit(await this.missionStatus());
414
+ return result;
415
+ }
416
+ // ---------- Accès existants ----------
417
+ /** Enregistre la disposition terminale d'un worker après observation/arrêt. */
418
+ async resolveWorker(workerId, disposition) {
419
+ await this.root.commit(async (tx) => {
420
+ const doc = await tx.doc(WorkerRecords, this.root.id);
421
+ const record = doc.workers.find((w) => w.id === workerId);
422
+ if (!record)
423
+ throw new Error(`worker inconnu: ${workerId}`);
424
+ record.disposition = disposition;
425
+ }, context);
426
+ await this.reconcileWorkers();
427
+ // Tout orphelin classé : la runtime redevient prête.
428
+ if (!this.recovery.needsAttention)
429
+ this.harness.resume();
430
+ this.control.emit(await this.missionStatus());
431
+ }
432
+ /** Transcript brut (vérité Durable — jamais recopié dans le catalogue, ADR-006 amendé). */
433
+ async transcript() {
434
+ return (await this.root.context(context)).entries;
435
+ }
436
+ /** Abonnement aux événements commités (fan-out SSE). */
437
+ async onCommitted(listener) {
438
+ const stream = await watchEvents(this.harness, this.root.id, context);
439
+ await stream.start(async (batch) => listener(batch));
440
+ return () => {
441
+ void stream.stop();
442
+ };
443
+ }
444
+ async waitForIdle() {
445
+ await this.root.waitForIdle(context);
446
+ }
447
+ /** Arrêt : retire les entrées en file et marque les tâches vivantes. */
448
+ async abort() {
449
+ await this.root.abort(context);
450
+ }
451
+ async close() {
452
+ this.closed = true;
453
+ try {
454
+ await this.harness.close(context);
455
+ }
456
+ finally {
457
+ this.lease.release();
458
+ }
459
+ }
460
+ }
@@ -0,0 +1,79 @@
1
+ /**
2
+ * Profil de mission figé (Plan 0002 §5 « Mission » + O6) — versions gelées à
3
+ * l'acceptation et vérifiées à chaque ouverture (preflight fail-closed).
4
+ *
5
+ * Durable possède la vérité de mission (D4) : le profil gelé vit dans le
6
+ * stockage Durable de la conversation, jamais dans le catalogue. Toute
7
+ * divergence SDK/preset/toolchain entre la création et une reprise rejette
8
+ * l'ouverture au lieu de changer les capacités d'une mission en vol.
9
+ */
10
+ import { createHash } from "node:crypto";
11
+ import { createRequire } from "node:module";
12
+ import { defineDoc } from "@earendil-works/pi-durable";
13
+ /** Version pinnée du SDK Durable (Plan 0002 §10, spike P0). */
14
+ export const DURABLE_SDK_PIN = "1.1.0";
15
+ const require = createRequire(import.meta.url);
16
+ /** Version réellement installée du SDK (sous-chemin package.json exporté par le paquet). */
17
+ export function installedDurableSdkVersion() {
18
+ const pkg = require("@earendil-works/pi-durable/package.json");
19
+ return pkg.version ?? "unknown";
20
+ }
21
+ export function digest(value) {
22
+ return createHash("sha256").update(value).digest("hex");
23
+ }
24
+ export const MissionProfile = defineDoc({
25
+ kind: "cogitator.mission-profile",
26
+ version: 1,
27
+ scope: "conversation",
28
+ history: "latest",
29
+ fork: "initial",
30
+ initial: () => ({
31
+ sdk: "",
32
+ presetDigest: "",
33
+ toolchain: { commands: [], mcpServers: [], extensions: [] },
34
+ createdAt: 0,
35
+ }),
36
+ });
37
+ export class MissionProfileFrozenError extends Error {
38
+ constructor(message) {
39
+ super(message);
40
+ this.name = "MissionProfileFrozenError";
41
+ }
42
+ }
43
+ export function freezeMissionProfile(presetDigest, toolchain) {
44
+ if (installedDurableSdkVersion() !== DURABLE_SDK_PIN) {
45
+ // Fail closed : on n'exécute pas une mission sur un SDK non pinné.
46
+ throw new MissionProfileFrozenError(`SDK Durable ${installedDurableSdkVersion()} ≠ pin ${DURABLE_SDK_PIN} : admission durable refusée`);
47
+ }
48
+ return { sdk: DURABLE_SDK_PIN, presetDigest, toolchain };
49
+ }
50
+ function sorted(values) {
51
+ return [...values].sort();
52
+ }
53
+ /** Compare le profil gelé (stockage Durable) aux versions installées. Toute divergence rejette. */
54
+ export function assertProfileFrozen(stored, expected, installedExtensions) {
55
+ if (!stored || stored.createdAt === 0) {
56
+ throw new MissionProfileFrozenError("mission durable sans profil gelé : refus d'ouverture (fail closed)");
57
+ }
58
+ if (stored.sdk !== expected.sdk) {
59
+ throw new MissionProfileFrozenError(`SDK Durable figé ${stored.sdk} ≠ installé ${expected.sdk}`);
60
+ }
61
+ if (stored.presetDigest !== expected.presetDigest) {
62
+ throw new MissionProfileFrozenError("snapshot preset figé divergent : la mission ne change pas de capacités en vol (O6)");
63
+ }
64
+ const same = (a, b) => a.length === b.length && sorted(a).every((v, i) => v === sorted(b)[i]);
65
+ if (!same(stored.toolchain.commands, expected.toolchain.commands)) {
66
+ throw new MissionProfileFrozenError("toolchain (commandes) divergente du gel de mission");
67
+ }
68
+ if (!same(stored.toolchain.mcpServers, expected.toolchain.mcpServers)) {
69
+ throw new MissionProfileFrozenError("toolchain (MCP) divergente du gel de mission");
70
+ }
71
+ if (!same(stored.toolchain.extensions, expected.toolchain.extensions)) {
72
+ throw new MissionProfileFrozenError("extensions durables divergentes du gel de mission");
73
+ }
74
+ for (const ext of stored.toolchain.extensions) {
75
+ if (!installedExtensions.includes(ext)) {
76
+ throw new MissionProfileFrozenError(`extension durable absente de l'installation: ${ext}`);
77
+ }
78
+ }
79
+ }
@@ -0,0 +1,42 @@
1
+ /**
2
+ * Identité et classification des workers de mission (Plan 0002 §5.7) : un
3
+ * crash peut laisser une commande worker en vie ; l'identité est persistée
4
+ * AVANT le dispatch, et au redémarrage on observe/arrête et on classe avant
5
+ * tout travail de remplacement.
6
+ */
7
+ import { defineDoc } from "@earendil-works/pi-durable";
8
+ export const WorkerRecords = defineDoc({
9
+ kind: "cogitator.workers",
10
+ version: 1,
11
+ scope: "conversation",
12
+ history: "latest",
13
+ fork: "initial",
14
+ initial: () => ({ workers: [] }),
15
+ });
16
+ /** true si un processus vit sous ce pid (ESRCH = mort ; EPERM = vivant, pas à nous). */
17
+ export function pidAlive(pid) {
18
+ if (!Number.isInteger(pid) || pid <= 0)
19
+ return false;
20
+ try {
21
+ process.kill(pid, 0);
22
+ return true;
23
+ }
24
+ catch (err) {
25
+ return err.code === "EPERM";
26
+ }
27
+ }
28
+ export function classifyWorker(record) {
29
+ if (record.disposition)
30
+ return { kind: "resolved", record };
31
+ if (pidAlive(record.pid))
32
+ return { kind: "live-orphan", record };
33
+ // Plus de processus et aucune disposition/receipt : l'issue est inétablie.
34
+ return { kind: "exited-unknown", record };
35
+ }
36
+ export function classifyWorkers(records) {
37
+ return records.map(classifyWorker);
38
+ }
39
+ /** Des workers non résolus (orphelin vivant OU issue inconnue) bloquent la reprise. */
40
+ export function unresolvedWorkers(classifications) {
41
+ return classifications.filter((c) => c.kind !== "resolved");
42
+ }
@@ -0,0 +1,45 @@
1
+ /**
2
+ * Admission disque et quotas (Skeptic S2 / Constraint Guardian CG1, Plan 0002 §8).
3
+ *
4
+ * Seuil d'admission : on refuse les nouvelles admissions sous le plus grand de
5
+ * 5 GiB ou 20 % d'espace libre, et on réserve de la capacité pour les
6
+ * checkpoints du contrôleur et les receipts d'effets. L'épuration ne touche
7
+ * jamais le travail actif ni les preuves non résolues : à capacité pleine, on
8
+ * alerte et on demande une décision de rétention explicite.
9
+ */
10
+ export const GIB = 1024 ** 3;
11
+ export const DEFAULT_DISK_POLICY = {
12
+ reserveBytes: 5 * GIB,
13
+ reserveFraction: 0.2,
14
+ workerQuotaBytes: 20 * GIB,
15
+ };
16
+ /** Admet un travail de `plannedBytes` s'il reste au-dessus du seuil de réserve. */
17
+ export function admissionDecision(policy, disk, plannedBytes) {
18
+ if (plannedBytes > policy.workerQuotaBytes) {
19
+ return { admit: false, reason: `quota worker dépassé (${plannedBytes} > ${policy.workerQuotaBytes} o)` };
20
+ }
21
+ const reserve = Math.max(policy.reserveBytes, Math.ceil(policy.reserveFraction * disk.totalBytes));
22
+ if (disk.freeBytes - plannedBytes < reserve) {
23
+ return { admit: false, reason: `seuil de réserve disque atteint (réserve ${reserve} o, libre ${disk.freeBytes} o)` };
24
+ }
25
+ return { admit: true };
26
+ }
27
+ /**
28
+ * Calcule ce qui PEUT être épuré. Invariants CG1 :
29
+ * - jamais le travail actif, jamais les preuves non résolues ;
30
+ * - jamais les transcripts, approbations ni receipts (autoritatifs, V1) ;
31
+ * - jamais les images épinglées ;
32
+ * - un clone/artifact terminal seulement après export ET expiration de rétention.
33
+ * Si le résultat ne libère pas assez d'espace, la décision est humaine.
34
+ */
35
+ export function prunePlan(entries) {
36
+ const prunable = [];
37
+ const protectedEntries = [];
38
+ for (const entry of entries) {
39
+ const isAuthoritative = entry.kind === "transcript" || entry.kind === "approval" || entry.kind === "receipt";
40
+ const kept = entry.active || entry.unresolvedEffects || entry.pinned || isAuthoritative ||
41
+ !entry.exported || entry.ageMs < entry.retentionMs;
42
+ (kept ? protectedEntries : prunable).push(entry);
43
+ }
44
+ return { prunable, protectedEntries };
45
+ }