brainclaw 1.26.2 → 1.28.0

package/dist/core/loops/types.js

@@ -15,7 +15,7 @@ export const REVIEW_MODES = ['asymmetric', 'symmetric'];
  */
 export const SLOT_STATUSES = ['open', 'assigned', 'working', 'waiting_input', 'done', 'failed', 'cancelled'];
 export const TERMINAL_SLOT_STATUSES = ['done', 'failed', 'cancelled'];
-export const LOOP_REF_KINDS = ['plan', 'sequence', 'claim', 'handoff', 'candidate', 'message'];
+export const LOOP_REF_KINDS = ['plan', 'sequence', 'claim', 'handoff', 'candidate', 'message', 'commit', 'branch'];
 export const LoopRefSchema = z.object({
     kind: z.enum(LOOP_REF_KINDS),
     id: z.string().min(1),
@@ -23,6 +23,8 @@ export const LoopRefSchema = z.object({
 export const LoopLinksSchema = z.object({
     plan_ids: z.array(z.string().min(1)).optional(),
     sequence_ids: z.array(z.string().min(1)).optional(),
+    /** Upstream loop in an ideation → implementation → review pipeline. */
+    source_loop_id: z.string().regex(/^lop_[0-9a-z]+$/).optional(),
 });
 /**
  * Memory categories a loop phase can request via `context_filter` (pln#492).
@@ -155,6 +157,13 @@ export const LoopSlotSchema = z.object({
     assignment_id: z.string().optional(),
     claim_id: z.string().optional(),
     phase: z.string().optional(),
+    /** Implementation-loop lane bound from the linked sequence at bind time. */
+    lane: z.string().optional(),
+    /** File/path scope carried by the bound sequence lane. */
+    scope_hint: z.string().optional(),
+    /** Plans and steps executed by this lane (derived, never worker-authored). */
+    plan_ids: z.array(z.string().min(1)).optional(),
+    step_ids: z.array(z.string().min(1)).optional(),
     status: z.enum(SLOT_STATUSES),
     /**
      * pln#630 PR2b-a (§13 R1) — pointer to the immutable turn-attempt record for
@@ -312,6 +321,74 @@ export const REF_BASED_ARTIFACT_TYPES = new Set([
     'signals_report',
     'file_diff',
 ]);
+export const EVIDENCE_ATTESTATION_KINDS = ['claim', 'observation', 'verification', 'approval'];
+export const EVIDENCE_PRODUCER_KINDS = ['engine', 'slot', 'coordinator', 'operator'];
+export const EVIDENCE_CHANNELS = [
+    'complete_turn',
+    'reconcile_turn',
+    'verify_command',
+    'add_artifact',
+    'operator_input',
+    'system_hook',
+];
+export const EvidenceSubjectSchema = z.object({
+    loop_id: z.string().regex(/^lop_[0-9a-z]+$/),
+    artifact_id: z.string().min(1),
+    phase: z.string().min(1),
+    iteration: z.number().int().nonnegative(),
+    slot_id: z.string().optional(),
+    turn_id: z.string().optional(),
+    assignment_id: z.string().optional(),
+    claim_id: z.string().optional(),
+    run_id: z.string().optional(),
+    nonce_digest: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+    attempt_epoch: z.number().int().nonnegative().optional(),
+    execution_contract_hash: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+    command_digest: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+    workspace_digest: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+});
+export const EvidenceProducerSchema = z.object({
+    kind: z.enum(EVIDENCE_PRODUCER_KINDS),
+    id: z.string().min(1),
+    agent_id: z.string().optional(),
+    channel: z.enum(EVIDENCE_CHANNELS),
+});
+export const EvidenceAttestationSchema = z.object({
+    kind: z.enum(EVIDENCE_ATTESTATION_KINDS),
+    issuer: z.string().min(1),
+    issued_at: z.string().datetime(),
+    subject_digest: z.string().regex(/^[0-9a-f]{64}$/),
+    rights: z.array(z.string().min(1)).min(1),
+});
+/**
+ * EvidenceEnvelope v1 is sealed by the loop engine at the artifact commit
+ * boundary. The seal is an integrity checksum, not a remote identity
+ * signature: ingress schemas never accept this object from a caller.
+ */
+export const EvidenceEnvelopeSchema = z.object({
+    version: z.literal(1),
+    evidence_id: z.string().regex(/^evd_[0-9a-z]+$/),
+    evidence_type: z.literal('artifact_commit'),
+    policy_version: z.literal('gate-policy-v1'),
+    subject: EvidenceSubjectSchema,
+    producer: EvidenceProducerSchema,
+    artifact_digest: z.string().regex(/^[0-9a-f]{64}$/),
+    issued_at: z.string().datetime(),
+    observed_at: z.string().datetime(),
+    validity: z.object({
+        not_before: z.string().datetime(),
+        not_after: z.string().datetime().optional(),
+    }),
+    attestations: z.array(EvidenceAttestationSchema).min(1),
+    seal: z.object({
+        algorithm: z.literal('sha256'),
+        digest: z.string().regex(/^[0-9a-f]{64}$/),
+    }),
+});
+export const EvidencePolicyBindingSchema = z.object({
+    version: z.literal('gate-policy-v1'),
+    mode: z.enum(['shadow', 'strict']),
+});
 /**
  * Lookup table mapping known artifact types to their body Zod schemas.
  * Step 2 handlers (request_input/provide_input) parse `artifact.body` as
@@ -339,6 +416,7 @@ export const REF_BASED_ARTIFACT_TYPES = new Set([
  */
 export const VerifyReportBodySchema = z.object({
     command: z.string().min(1),
+    command_argv: z.array(z.string()).min(1).optional(),
     exit_code: z.number().int().nullable(),
     passed: z.boolean(),
     duration_ms: z.number().int().nonnegative().optional(),
@@ -346,6 +424,11 @@ export const VerifyReportBodySchema = z.object({
     timed_out: z.boolean().optional(),
     stdout_tail: z.string().max(1024).optional(),
     stderr_tail: z.string().max(1024).optional(),
+    command_digest: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+    workspace_digest: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+    workspace_stable: z.boolean().optional(),
+    /** Implementation lane whose worktree was verified. */
+    lane: z.string().optional(),
 });
 export const KNOWN_ARTIFACT_BODY_SCHEMAS = {
     // inline JSON body: body = JSON.stringify({ ...fields per OperatorQuestionBodySchema })
@@ -385,6 +468,8 @@ export const LoopArtifactSchema = z
      * critique artifact) is deferred to v1.1 per the plan.
      */
     addresses_critique: z.array(z.string().min(1)).optional(),
+    /** Executable acceptance command carried from synthesis into implementation. */
+    implementation_verify: LoopVerifyConfigSchema.optional(),
     /**
      * pln#492 phase 2.b — iteration window the artifact was produced in.
      * 0-indexed (proposal/early phases produce iteration=0). Optional for
@@ -394,6 +479,14 @@ export const LoopArtifactSchema = z
      * at artifact creation time so callers don't have to track it.
      */
     iteration: z.number().int().nonnegative().optional(),
+    /**
+     * Explicit migration provenance. Optional on read so artifacts persisted
+     * before P2 remain valid; use artifactEvidenceProvenance() to infer their
+     * effective value without rewriting historical records.
+     */
+    provenance: z.enum(['legacy', 'attested']).optional(),
+    /** Server-sealed provenance and independent attestations (P2). */
+    evidence: EvidenceEnvelopeSchema.optional(),
 })
     .superRefine((artifact, ctx) => {
     if (artifact.body !== undefined && Buffer.byteLength(artifact.body, 'utf8') > LOOP_ARTIFACT_BODY_MAX_BYTES) {
@@ -500,6 +593,8 @@ export const LoopThreadSchema = z
     artifacts: z.array(LoopArtifactSchema),
     linked: LoopLinksSchema.optional(),
     stop_condition: StopConditionSchema.optional(),
+    /** Absent means a pre-policy/legacy thread. New loops bind this at open. */
+    evidence_policy: EvidencePolicyBindingSchema.optional(),
     /**
      * pln#508 step 1 — set of unresolved operator_question artifact ids.
      * The engine maintains this on every request_input / provide_input
@@ -580,6 +675,17 @@ const LoopEventBaseShape = {
     by: z.string().optional(),
     mutation_id: z.string().min(1),
 };
+export const GateDecisionSchema = z.object({
+    passed: z.boolean(),
+    /** Strict and legacy dimensions remain observable during a shadow rollout. */
+    strict_passed: z.boolean().optional(),
+    legacy_passed: z.boolean().optional(),
+    policy_version: z.enum(['legacy', 'gate-policy-v1']),
+    mode: z.enum(['legacy', 'shadow', 'strict']),
+    condition_digest: z.string().regex(/^[0-9a-f]{64}$/),
+    accepted_evidence_ids: z.array(z.string()),
+    rejected: z.array(z.object({ artifact_id: z.string(), reason: z.string() })),
+});
 export const LoopEventSchema = z.discriminatedUnion('kind', [
     z.object({
         ...LoopEventBaseShape,
@@ -594,6 +700,7 @@ export const LoopEventSchema = z.discriminatedUnion('kind', [
         to_phase: z.string().min(1),
         iteration: z.number().int().nonnegative(),
         reason: z.string().optional(),
+        gate_decision: GateDecisionSchema.optional(),
     }),
     z.object({
         ...LoopEventBaseShape,
@@ -615,6 +722,19 @@ export const LoopEventSchema = z.discriminatedUnion('kind', [
         phase: z.string().min(1),
         turn_id: z.string().min(1),
     }),
+    z.object({
+        ...LoopEventBaseShape,
+        kind: z.literal('attempt_generation_changed'),
+        slot_id: z.string().min(1),
+        turn_id: z.string().min(1),
+        assignment_id: z.string().min(1),
+        from_epoch: z.number().int().nonnegative(),
+        to_epoch: z.number().int().positive(),
+        from_run_id: z.string().min(1),
+        to_run_id: z.string().min(1),
+        close_digest: z.string().regex(/^[a-f0-9]{64}$/),
+        cause: z.string().min(1),
+    }),
     z.object({
         ...LoopEventBaseShape,
         kind: z.literal('turn_completed'),
@@ -631,6 +751,7 @@ export const LoopEventSchema = z.discriminatedUnion('kind', [
         phase: z.string().min(1),
         type: z.string().min(1),
         produced_by: z.string().optional(),
+        evidence_id: z.string().optional(),
     }),
     z.object({
         ...LoopEventBaseShape,
@@ -651,6 +772,7 @@ export const LoopEventSchema = z.discriminatedUnion('kind', [
         kind: z.literal('closed'),
         final_status: z.enum(['completed', 'cancelled', 'blocked']),
         reason: z.string().optional(),
+        gate_decision: GateDecisionSchema.optional(),
     }),
     // pln#492 — system events emitted by the iteration / phase-advance gate.
     // Carried in the same event journal rather than as artifacts so consumers
@@ -660,6 +782,7 @@ export const LoopEventSchema = z.discriminatedUnion('kind', [
         kind: z.literal('phase_advance_blocked'),
         phase: z.string().min(1),
         gate_reason: z.string().min(1),
+        gate_decision: GateDecisionSchema.optional(),
     }),
     z.object({
         ...LoopEventBaseShape,
@@ -783,8 +906,9 @@ export const DEFAULT_PROTOCOLS = {
     },
     // pln#609 — implementation loop v2. The loop ADDS to the dispatch pipeline
     // what it lacked: a deterministic command_green gate + a bounded fix↔verify
-    // cycle + per-phase context sculpting. `bind` is an ENGINE action (bind
-    // plan+sequence and dispatch) not narration; execute↔verify iterates until
+    // cycle + per-phase context sculpting. `bind` is an engine-only link
+    // validation/advance; worker launch belongs to turn(dispatch=true).
+    // execute↔verify iterates until
     // the verify command is green (a passing verify_report this iteration) or
     // the cycle cap is hit (→ handoff_ready with the red report → blocked).
     implementation: {