mishkan-harness 0.2.0 → 0.2.3

package/payload/mishkan/workflows/migdal-infra-change.js

@@ -0,0 +1,67 @@
+// migdal-infra-change — infra change validated by 5 orthogonal lenses.
+//
+// An infra change (Terraform module, Helm chart, K8s manifest, network rule)
+// goes in; five lenses verify in parallel: design intent, systems/blast radius,
+// devops/rollback path, observability impact, post-change health checks.
+// Output is go/no-go with named blockers.
+//
+// Pattern: barrier `parallel()` per lens + synthesis.
+// ADR D-010 check:
+//   - panel orthogonality: design / systems / devops / observability / health
+//     are distinct domains.
+//   - synthesis: structured go/no-go with rollback path attached.
+
+export const meta = {
+  name: "migdal-infra-change",
+  description: "Infra change validated by 5 orthogonal lenses (design / systems / devops / observability / health).",
+  whenToUse: "Before applying any infra change with non-trivial blast radius (network, IAM, scaling, cross-service deps).",
+  phases: [{ title: "Review" }, { title: "Decide" }],
+};
+
+const changeDescription = args?.change_description;
+const changeFiles = args?.change_files ?? [];
+const project = args?.project ?? ".";
+if (!changeDescription) throw new Error("args.change_description is required");
+
+const VERDICT_SCHEMA = {
+  type: "object", required: ["safe", "rationale"],
+  properties: { safe: {type:"boolean"}, rationale: {type:"string"}, blockers: {type:"array", items:{type:"string"}}, mitigations: {type:"array", items:{type:"string"}}, rollback_steps: {type:"array", items:{type:"string"}} },
+};
+
+phase("Review");
+const LENSES = [
+  { key: "design",   agent: "meshullam", prompt: "Infrastructure design: does this change cohere with existing infra patterns? Any redesign required upstream?" },
+  { key: "systems",  agent: "palal",     prompt: "Systems / blast radius: network impact, OS-level changes, virt layer, dependent services. What goes down if this fails?" },
+  { key: "devops",   agent: "meremoth",  prompt: "Devops / pipeline: deployment path, rollback procedure, CI/CD impact, secret rotations needed." },
+  { key: "obs",      agent: "hanun",     prompt: "Observability: metrics/logs/traces impact, alert rules to add, dashboards to update, SLO implications." },
+  { key: "health",   agent: "rehum",     prompt: "Post-change health: health checks to run after apply, probes to add, smoke tests, expected steady-state metrics." },
+];
+
+const verdicts = await parallel(LENSES.map(L => () =>
+  agent(
+    `Infra change: ${changeDescription}. Files: ${JSON.stringify(changeFiles)}. Project: ${project}. Your lens: ${L.prompt} Default safe=false if uncertain — infra changes are high-stakes.`,
+    { schema: VERDICT_SCHEMA, label: `review:${L.key}`, agentType: L.agent, phase: "Review" },
+  ).then(v => ({ lens: L.key, ...v }))
+));
+
+const valid = verdicts.filter(Boolean);
+const safeCount = valid.filter(v => v.safe).length;
+const allBlockers = valid.flatMap(v => v.blockers ?? []);
+const allMitigations = valid.flatMap(v => v.mitigations ?? []);
+const rollback = valid.flatMap(v => v.rollback_steps ?? []);
+
+phase("Decide");
+return {
+  change: changeDescription,
+  change_files: changeFiles,
+  lens_verdicts: valid,
+  safe_count: safeCount,
+  all_safe: safeCount === LENSES.length,
+  blockers: allBlockers,
+  mitigations: allMitigations,
+  rollback_plan: rollback,
+  decision: safeCount === LENSES.length ? "go" : "no-go",
+  summary: safeCount === LENSES.length
+    ? `Infra change GO. ${safeCount}/5 lenses safe. Rollback path: ${rollback.length} steps documented.`
+    : `Infra change NO-GO. ${LENSES.length - safeCount}/5 lenses flagged blockers. Address: ${allBlockers.slice(0,3).join(" | ")}`,
+};

package/payload/mishkan/workflows/mishkan-blast-radius.js

@@ -0,0 +1,144 @@
+// mishkan-blast-radius — what does this change actually touch?
+//
+// Given a refactor target (symbol/function/class), walk the Graphify
+// reverse-call graph for each impacted call site, then adversarially
+// verify each "this is impacted" claim with three load-bearing lenses
+// (caller-side / data-contract / runtime-behavior) so false-positive
+// impacted sites get filtered out before the engineer schedules work.
+//
+// Pattern: Graphify discovery → parallel fan-out per call site →
+// adversarial verify (3-lens panel) → synthesis.
+//
+// Per PM+CTO portfolio review (2026-06-07):
+//  - Nehemiah: keep — recurrence justified for every non-trivial refactor.
+//    Must be gated by /plan approval before invocation. Renamed from
+//    `mishkan-graphify-impact-audit` to drop implementation detail from
+//    the user-facing name.
+//  - Bezalel: keep + rework with three EXPLICIT lenses that are
+//    orthogonal (not 70%-overlapping), and a short-circuit when Graphify
+//    returns < N nodes so we don't burn tokens on empty fanouts.
+//
+// Args (passed via Workflow `args`):
+//   { target: "process_payment", depth: 3, project: "/path/to/repo",
+//     min_sites_to_verify: 2 }   // short-circuit threshold
+//
+// Pre-req: the project has been scanned (graphify update .). Workflow
+// emits a single graphify_query to gather impacted sites; that's the budget.
+
+export const meta = {
+  name: "mishkan-blast-radius",
+  description: "What does this change actually touch? Graphify discovery + 3-lens orthogonal verify per impacted site.",
+  whenToUse: "Before editing a function whose downstream impact you don't fully know. Gated by /plan approval per the harness sequence rule.",
+  phases: [
+    { title: "Discover" },
+    { title: "Verify" },
+    { title: "Synthesize" },
+  ],
+};
+
+const target = args?.target;
+const depth = args?.depth ?? 3;
+const project = args?.project ?? ".";
+const MIN_SITES = args?.min_sites_to_verify ?? 2;
+if (!target) throw new Error("args.target is required (the symbol/function/class to audit)");
+
+const IMPACTED_SCHEMA = {
+  type: "object",
+  required: ["sites"],
+  properties: {
+    sites: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["file", "symbol", "reason"],
+        properties: {
+          file: { type: "string" },
+          line: { type: "integer" },
+          symbol: { type: "string" },
+          reason: { type: "string" },
+          relation: { type: "string" },
+        },
+      },
+    },
+  },
+};
+
+const VERDICT_SCHEMA = {
+  type: "object",
+  required: ["really_impacted", "confidence", "rationale"],
+  properties: {
+    really_impacted: { type: "boolean" },
+    confidence: { type: "string", enum: ["low", "medium", "high"] },
+    rationale: { type: "string" },
+    suggested_action: { type: "string" },
+  },
+};
+
+// Three ORTHOGONAL lenses per Bezalel — each load-bearing, no overlap.
+// caller-side    = the SHAPE of the call: signature, types, exception contract.
+// data-contract  = the DATA flowing through: invariants, schema, nullability.
+// runtime        = the RUNTIME behavior: ordering, side effects, timing, perf.
+const LENSES = [
+  {
+    key: "caller",
+    prompt: "Will the SHAPE of THIS call site break? Signature change, type mismatch, new/removed exception, async/sync mismatch — purely the call protocol, not the data semantics.",
+  },
+  {
+    key: "data",
+    prompt: "Will the DATA semantics break? Invariants this call site assumes about the target's input/output, nullability, ordering of fields, encoding — purely the data contract, not the call protocol.",
+  },
+  {
+    key: "runtime",
+    prompt: "Will the RUNTIME behavior break? Side effects this call site depends on, timing/ordering guarantees, performance characteristics, thread/event-loop assumptions — purely runtime, not data or shape.",
+  },
+];
+
+phase("Discover");
+const discovery = await agent(
+  `Run \`graphify affected "${target}" --depth ${depth} --relations calls,imports --graph ${project}/graphify-out/graph.json\` and parse the impacted call sites it returns. Cite file:line per site. Return strictly the schema.`,
+  { schema: IMPACTED_SCHEMA, label: `discover:${target}` },
+);
+const sites = discovery?.sites ?? [];
+log(`Discovered ${sites.length} potentially impacted sites.`);
+
+// Short-circuit: empty fan-out is wasted tokens.
+if (sites.length < MIN_SITES) {
+  return {
+    target,
+    impacted: sites,
+    short_circuited: true,
+    summary: `Discovered ${sites.length} sites (< MIN_SITES=${MIN_SITES}). Verification skipped. Either the target has no callers worth verifying, or the graph is stale — run \`graphify update .\` and retry.`,
+  };
+}
+
+phase("Verify");
+const verifiedSites = await parallel(sites.map(site => () =>
+  parallel(LENSES.map(L => () =>
+    agent(
+      `Refactor target: ${target}. Impacted site: ${site.file}:${site.line ?? "?"} (${site.symbol}) — graph reason: "${site.reason}". Lens: ${L.prompt} Default to really_impacted=false if uncertain — we tolerate misses, not false positives.`,
+      { schema: VERDICT_SCHEMA, label: `verify:${L.key}:${site.symbol}`, phase: "Verify" },
+    )
+  ))
+  .then(verdicts => {
+    const valid = verdicts.filter(Boolean);
+    const really = valid.filter(v => v.really_impacted).length;
+    return {
+      site,
+      lens_verdicts: valid,
+      lens_really_count: really,
+      // Confirmed = majority across the THREE orthogonal lenses.
+      confirmed: really >= 2,
+    };
+  })
+));
+
+const confirmed = verifiedSites.filter(v => v.confirmed);
+log(`${confirmed.length}/${sites.length} sites confirmed by orthogonal majority (>=2 of 3 lenses).`);
+
+phase("Synthesize");
+const summary = await agent(
+  `Refactor target: ${target}. Confirmed impacted sites: ${JSON.stringify(confirmed.map(c => ({file: c.site.file, symbol: c.site.symbol, votes: c.lens_really_count, top_lens: c.lens_verdicts.find(v => v.really_impacted)?.rationale})))}. Produce a 6-10 line engineer-action summary: how many sites, the highest-risk one + which lens flagged it, suggested PR sequence (independent first, then coupled). No fluff.`,
+  { label: "synthesize", phase: "Synthesize" },
+);
+
+return { target, impacted: confirmed, summary };

package/payload/mishkan/workflows/mishkan-init.js

@@ -22,7 +22,19 @@ export const meta = {
   name: 'mishkan-init',
   description: 'Pipelined PRD → SRS → CONTRACT → ARCHITECTURE → THREAT_MODEL → C4. Downstream stages start as soon as their upstream dependency lands; sequence rule preserved.',
   whenToUse: 'Once per project at /mishkan-init. Brownfield mode uses the same shape with read-existing instead of write-new at each stage.',
+  // Phase 1 canary for the skill-discovery layer (D-011). The router uses
+  // these to apply a ×1.5 category prior when surfacing candidate skills
+  // during the SkillRouter phase below. The actual loading decision stays
+  // with the model; the router is advisory.
+  relevant_skill_categories: [
+    'craft',
+    'mishkan-workflow',
+    'docs',
+    'security',
+    'process',
+  ],
   phases: [
+    { title: 'SkillRouter',  detail: 'Skill-discovery router surfaces relevant skills (advisory)' },
     { title: 'PRD',          detail: 'Nehemiah writes the product requirement document' },
     { title: 'SRS',          detail: 'Nathan turns PRD into a testable system requirement spec' },
     { title: 'CONTRACT+ARCH',detail: 'Zadok writes CONTRACT; Nathan writes ARCHITECTURE — in parallel' },
@@ -48,6 +60,51 @@ const ARTEFACT_SCHEMA = {
 
 const STACK = args.stack_hint || 'undetermined'
 
+// --- Stage 0: SkillRouter (canary, advisory) --------------------------
+// Surfaces candidate skills relevant to the init task. Pure read; never
+// blocks. Result is passed into the Bezalel signoff prompt at Settle so
+// the CTO sees what the model could have reached for. Fail-open: any
+// router error is logged and the workflow continues.
+phase('SkillRouter')
+let skillCandidates = null
+try {
+  const cats = (meta.relevant_skill_categories || []).join(',')
+  const routerTask =
+    `Initialise project "${args.project_name}" under MISHKAN. ` +
+    `Intent: ${args.raw_intent}. Stack: ${STACK}. ` +
+    `Produce PRD, SRS, CONTRACT, ARCHITECTURE, THREAT_MODEL, C4, docs scaffold.`
+  // The runner is expected to execute the python helper out-of-band; if it
+  // does not, the catch below logs the miss and we continue.
+  skillCandidates = await agent(
+    `Invoke the skill-discovery router as an advisory pass. Run:\n` +
+    `  python3 ~/.claude/mishkan/scripts/skill-discovery-router.py ` +
+    `--task ${JSON.stringify(routerTask)} ` +
+    `--workflow mishkan-init ` +
+    `--relevant-categories ${JSON.stringify(cats)}\n` +
+    `Return the parsed JSON output verbatim. Do not load any of the ` +
+    `surfaced skills. This pass is advisory only — the loading decision ` +
+    `stays with the model and with Bezalel at Settle.`,
+    {
+      label: 'skill-discovery:router',
+      phase: 'SkillRouter',
+      agentType: 'skill-discovery',
+      schema: {
+        type: 'object',
+        required: ['task_summary'],
+        properties: {
+          task_summary:    { type: 'string' },
+          must_load:       { type: 'array' },
+          should_consider: { type: 'array' },
+          adjacent:        { type: 'array' },
+          warnings:        { type: 'array', items: { type: 'string' } },
+        },
+      },
+    }
+  )
+} catch (err) {
+  skillCandidates = { error: String(err), warnings: ['router_invocation_failed'] }
+}
+
 // --- Stage 1: PRD ------------------------------------------------------
 phase('PRD')
 const prd = await agent(
@@ -149,6 +206,7 @@ return {
     prd, srs, contract, architecture, threat, c4,
     docs_scaffold: docsScaffold,
   },
+  skill_candidates: skillCandidates,
   bezalel_signoff: signoff,
   next: signoff?.status === 'accepted'
     ? `Init complete. Begin Sprint S0; Nehemiah leads. Hand the directory state to Y4NN for git init + first commit.`

package/payload/mishkan/workflows/mishkan-knowledge-gap-discovery.js

@@ -0,0 +1,121 @@
+// mishkan-knowledge-gap-discovery — find what we DON'T have in Cognee.
+//
+// Given an expected concept list (e.g. "what every project should have an
+// ADR for"), probe Cognee work for each — when nothing relevant comes back
+// for K rounds in a row, declare the concept a gap and dispatch a research
+// pipeline run to fill it. Loop-until-dry on the gap discovery side.
+//
+// Pattern: parallel probe → loop-until-dry per concept → research fan-out
+// for confirmed gaps → write findings back to Cognee work.
+//
+// Args:
+//   { concepts: ["authentication ADR", "rate-limit runbook", ...],
+//     dry_rounds: 2,
+//     research_budget_per_gap: 5000 }
+
+export const meta = {
+  name: "mishkan-knowledge-gap-discovery",
+  description: "Probe Cognee work for an expected concept list, identify gaps with loop-until-dry, dispatch research to fill confirmed gaps.",
+  whenToUse: "Sprint-close audit, onboarding a new project, post-incident knowledge inventory. Anywhere you suspect 'we have less written down than we think'.",
+  phases: [
+    { title: "Probe" },
+    { title: "ConfirmGaps" },
+    { title: "Fill" },
+  ],
+};
+
+const concepts = args?.concepts;
+const DRY_ROUNDS = args?.dry_rounds ?? 2;
+const RESEARCH_BUDGET = args?.research_budget_per_gap ?? 5000;
+if (!Array.isArray(concepts) || !concepts.length) {
+  throw new Error("args.concepts must be a non-empty list of expected-concept strings");
+}
+
+const PROBE_SCHEMA = {
+  type: "object",
+  required: ["concept", "matches"],
+  properties: {
+    concept: { type: "string" },
+    matches: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["node_id", "title", "relevance"],
+        properties: {
+          node_id: { type: "string" },
+          title: { type: "string" },
+          relevance: { type: "string", enum: ["strong", "weak", "none"] },
+        },
+      },
+    },
+  },
+};
+
+const RESEARCH_FINDING_SCHEMA = {
+  type: "object",
+  required: ["concept", "summary", "sources"],
+  properties: {
+    concept: { type: "string" },
+    summary: { type: "string" },
+    sources: { type: "array", items: { type: "string" } },
+    suggested_cognee_node_type: { type: "string" },
+  },
+};
+
+phase("Probe");
+log(`Probing ${concepts.length} concepts against Cognee work…`);
+
+const initial = await parallel(concepts.map(concept => () =>
+  agent(
+    `Search Cognee work store for "${concept}". Use the cognee-search MCP tool. Classify each hit's relevance to the literal concept (strong/weak/none). Return strictly the schema.`,
+    { schema: PROBE_SCHEMA, label: `probe:${concept.slice(0, 24)}` },
+  )
+));
+
+const strong = (r) => (r?.matches ?? []).filter(m => m.relevance === "strong").length;
+
+const gaps = initial.filter(Boolean).filter(r => strong(r) === 0).map(r => r.concept);
+log(`Initial probe: ${gaps.length}/${concepts.length} concepts have NO strong match in Cognee work.`);
+
+phase("ConfirmGaps");
+const confirmedGaps = [];
+for (const gap of gaps) {
+  let dryRounds = 0;
+  let rephraseCount = 0;
+  while (dryRounds < DRY_ROUNDS && rephraseCount < 4) {
+    rephraseCount++;
+    const reprobe = await agent(
+      `Search Cognee work for the same concept under a different phrasing (paraphrase ${rephraseCount}/4 of "${gap}"). Different wording, same semantic intent. Return the schema.`,
+      { schema: PROBE_SCHEMA, label: `reprobe:${gap.slice(0, 18)}/${rephraseCount}`, phase: "ConfirmGaps" },
+    );
+    if (reprobe && strong(reprobe) > 0) {
+      log(`"${gap}" — found via paraphrase ${rephraseCount}, NOT a gap.`);
+      dryRounds = -1;
+      break;
+    }
+    dryRounds++;
+  }
+  if (dryRounds >= DRY_ROUNDS) {
+    confirmedGaps.push(gap);
+  }
+}
+log(`${confirmedGaps.length} confirmed gaps after ${DRY_ROUNDS}-round dry-confirmation.`);
+
+if (!confirmedGaps.length) {
+  return { probed: concepts.length, gaps: 0, summary: "No confirmed gaps — every expected concept has at least a paraphrased match in Cognee work." };
+}
+
+phase("Fill");
+const findings = await parallel(confirmedGaps.map(gap => () =>
+  agent(
+    `Run the MISHKAN research pipeline (Jakin → Ezra → Caleb → Shaphan → Shemaiah → Baruch) for: "${gap}". Token budget: ${RESEARCH_BUDGET}. Produce a finding suitable for ingestion into Cognee work as a new node. Return the schema.`,
+    { schema: RESEARCH_FINDING_SCHEMA, label: `research:${gap.slice(0, 18)}`, phase: "Fill" },
+  )
+));
+
+return {
+  probed: concepts.length,
+  gaps_confirmed: confirmedGaps.length,
+  findings: findings.filter(Boolean),
+  summary: `Probed ${concepts.length} concepts, confirmed ${confirmedGaps.length} gaps, produced ${findings.filter(Boolean).length} research findings ready to cognify.`,
+};

package/payload/mishkan/workflows/mishkan-standards-rollout.js

@@ -0,0 +1,153 @@
+// mishkan-standards-rollout — propagate a new standard across the 6 teams.
+//
+// When y4nn-standards.md gains a new rule (security, infra, doc convention,
+// language standard), the rule needs to land in each Team's path-scoped rules
+// + each Team Lead needs to verify their team's agents align + Bezalel
+// ratifies the final state. Today this is manual and drifts — different
+// teams adopt at different velocities and the harness silently diverges.
+//
+// Pattern: pipeline (propose → translate per team → verify per team → ratify)
+// + barrier (all 6 Team Leads must verify before Bezalel can ratify)
+// + judge panel (Bezalel + Phinehas + Jehoshaphat ratify).
+//
+// Per PM+CTO portfolio review (2026-06-07):
+//  - Bezalel's #1 pick: rules drift is the highest-cost silent failure
+//    mode in MISHKAN. A workflow gate is the only durable fix.
+//  - Nehemiah aligned: cross-team coordination of standards is recurrent
+//    each time a new rule lands.
+//
+// Args:
+//   { rule_text: "...the new standard text, in prose...",
+//     rule_id: "RULE-2026-06-007",
+//     scope_hint: "security" | "infra" | "doc" | "code" | "process" }
+
+export const meta = {
+  name: "mishkan-standards-rollout",
+  description: "Propagate a new standard across the 6 teams with per-team translation, verification, and CTO ratification.",
+  whenToUse: "When y4nn-standards.md or a team rule gains a new rule that other teams must adopt. Run BEFORE the rule is considered shipped.",
+  phases: [
+    { title: "Translate" },
+    { title: "Verify" },
+    { title: "Ratify" },
+  ],
+};
+
+const ruleText = args?.rule_text;
+const ruleId = args?.rule_id ?? `RULE-${new Date().toISOString().slice(0,10)}`;
+const scopeHint = args?.scope_hint ?? "code";
+if (!ruleText) throw new Error("args.rule_text is required");
+
+const TEAMS = [
+  { name: "Chosheb",  lead: "aholiab",     domain: "Design / UX" },
+  { name: "Panim",    lead: "huram",       domain: "Frontend" },
+  { name: "Yasad",    lead: "zerubbabel",  domain: "Backend / data" },
+  { name: "Mishmar",  lead: "phinehas",    domain: "Security (cross-cutting)" },
+  { name: "Migdal",   lead: "eliashib",    domain: "Infrastructure / ops" },
+  { name: "Sefer",    lead: "jehoshaphat", domain: "Documentation" },
+];
+
+const TRANSLATION_SCHEMA = {
+  type: "object",
+  required: ["applies", "rule_in_team_voice", "impact"],
+  properties: {
+    applies: { type: "boolean" },
+    rule_in_team_voice: { type: "string" },
+    impact: { type: "string", enum: ["none", "small", "medium", "large"] },
+    breaking_for: { type: "array", items: { type: "string" } },
+    rationale: { type: "string" },
+  },
+};
+
+const VERIFICATION_SCHEMA = {
+  type: "object",
+  required: ["aligned", "drift_found"],
+  properties: {
+    aligned: { type: "boolean" },
+    drift_found: { type: "array", items: { type: "string" } },
+    remediation_needed: { type: "string" },
+  },
+};
+
+const RATIFY_SCHEMA = {
+  type: "object",
+  required: ["ratified", "rationale"],
+  properties: {
+    ratified: { type: "boolean" },
+    rationale: { type: "string" },
+    blockers: { type: "array", items: { type: "string" } },
+  },
+};
+
+phase("Translate");
+// Per-team translation. Each Team Lead decides if the rule applies to
+// their team and what it means in their team's voice / vocabulary /
+// path-scoped rule file.
+const translations = await parallel(TEAMS.map(T => () =>
+  agent(
+    `New ${scopeHint} standard ${ruleId} just landed at the harness level. Verbatim text: """${ruleText}""" In your role as ${T.name} (${T.domain}) team lead, decide: does this apply to YOUR team? If yes, how would you write it in your team's voice for your path-scoped rules file? If no, justify briefly. Return the schema.`,
+    { schema: TRANSLATION_SCHEMA, label: `translate:${T.name}`, agentType: T.lead, phase: "Translate" },
+  ).then(t => ({ ...T, ...t }))
+));
+
+const applies = translations.filter(Boolean).filter(t => t.applies);
+log(`Rule ${ruleId} applies to ${applies.length}/${TEAMS.length} teams.`);
+
+if (!applies.length) {
+  return {
+    rule_id: ruleId,
+    decision: "noop",
+    summary: "No team's rules need updating for this standard. Y4NN-standards.md amendment alone is sufficient.",
+  };
+}
+
+phase("Verify");
+// Per-team verification: does the team's CURRENT agents/specialists/skills
+// already align with this rule, or is there drift to remediate?
+const verifications = await parallel(applies.map(T => () =>
+  agent(
+    `Standard ${ruleId} now applies to your team (${T.name}). Translated form: "${T.rule_in_team_voice}" Check your team's agents, skills, and existing rules for DRIFT — places that already contradict or won't propagate this rule. Return the schema.`,
+    { schema: VERIFICATION_SCHEMA, label: `verify:${T.name}`, agentType: T.lead, phase: "Verify" },
+  ).then(v => ({ team: T.name, lead: T.lead, ...v }))
+));
+
+const drifting = verifications.filter(Boolean).filter(v => !v.aligned || (v.drift_found?.length ?? 0) > 0);
+log(`${drifting.length}/${applies.length} applying teams have drift to remediate.`);
+
+phase("Ratify");
+// Bezalel (CTO) + Phinehas (security cross-cutting if scope=security) +
+// Jehoshaphat (Sefer/doc convention if scope=doc) ratify.
+const ratifiers = [
+  { role: "bezalel",     focus: "CTO — architecture and standards consistency across the harness" },
+];
+if (scopeHint === "security") {
+  ratifiers.push({ role: "phinehas", focus: "Mishmar lead — cross-cutting security impact" });
+}
+if (scopeHint === "doc") {
+  ratifiers.push({ role: "jehoshaphat", focus: "Sefer lead — documentation convention impact" });
+}
+
+const ratifications = await parallel(ratifiers.map(R => () =>
+  agent(
+    `Standard ${ruleId} rollout review. ${R.focus} ` +
+    `Translations: ${JSON.stringify(applies.map(t => ({team: t.name, voice: t.rule_in_team_voice, impact: t.impact})))} ` +
+    `Verifications: ${JSON.stringify(verifications.filter(Boolean))} ` +
+    `Should this rule ship as-is, or are there blockers? Return the schema.`,
+    { schema: RATIFY_SCHEMA, label: `ratify:${R.role}`, agentType: R.role, phase: "Ratify" },
+  ).then(r => ({ role: R.role, ...r }))
+));
+
+const allRatified = ratifications.filter(Boolean).every(r => r.ratified);
+const allBlockers = ratifications.filter(Boolean).flatMap(r => r.blockers ?? []);
+
+return {
+  rule_id: ruleId,
+  scope_hint: scopeHint,
+  applies_to_teams: applies.map(t => t.name),
+  drifting_teams: drifting.map(d => d.team),
+  ratifications,
+  decision: allRatified ? "ship" : "block",
+  blockers: allBlockers,
+  summary: allRatified
+    ? `Rule ${ruleId} ratified by ${ratifications.length} reviewers. Applies to ${applies.length} teams; ${drifting.length} need drift remediation per the verification report.`
+    : `Rule ${ruleId} BLOCKED. ${allBlockers.length} blockers across ${ratifications.length} reviewers. Address blockers before re-running.`,
+};

package/payload/mishkan/workflows/mishmar-security-gate.js

@@ -0,0 +1,83 @@
+// mishmar-security-gate — security gate before merge on sensitive surface.
+//
+// A diff that touches sensitive surface (auth, payment, PII, secrets, RBAC)
+// goes in; three orthogonal security lenses verify in parallel with 3-vote
+// refute pattern. Output is pass/block + structured findings.
+//
+// Pattern: barrier + 3-vote adversarial verify (each finding refuted by 2 of 3).
+// ADR D-010 check:
+//   - panel orthogonality: Ira (code-level OWASP injection),
+//     Joab (surface attack vectors), Hushai (advisor on threat model) —
+//     distinct evaluation domains.
+//   - synthesis: pass/block decision with finding list.
+
+export const meta = {
+  name: "mishmar-security-gate",
+  description: "Security gate before merge on sensitive surface — 3 orthogonal lenses + adversarial refute.",
+  whenToUse: "Before merging changes that touch auth, payment, PII, secrets, RBAC, crypto.",
+  phases: [{ title: "Find" }, { title: "Refute" }, { title: "Decide" }],
+};
+
+const diffRef = args?.diff_ref;
+const surface = args?.surface;
+const project = args?.project ?? ".";
+if (!diffRef) throw new Error("args.diff_ref is required (PR URL, branch, or diff path)");
+if (!surface) throw new Error("args.surface is required (e.g. 'auth' | 'payment' | 'pii' | 'rbac')");
+
+const FINDING_SCHEMA = {
+  type: "object", required: ["findings"],
+  properties: { findings: { type: "array", items: { type: "object", required: ["title", "severity", "rationale"], properties: { title: {type:"string"}, severity: {type:"string", enum:["info","low","medium","high","critical"]}, file: {type:"string"}, line: {type:"integer"}, rationale: {type:"string"} } } } },
+};
+const REFUTE_SCHEMA = {
+  type: "object", required: ["refuted", "rationale"],
+  properties: { refuted: {type:"boolean"}, rationale: {type:"string"} },
+};
+
+phase("Find");
+const LENSES = [
+  { key: "code-owasp", agent: "ira",    prompt: "OWASP Top 10 at the code level: injection, broken auth, broken access, SSRF, deserialization, secrets. Inspect the diff line-by-line." },
+  { key: "surface",    agent: "joab",   prompt: "Surface attack vectors: input validation gaps, AuthZ boundary checks, CSRF/CORS, rate limits, error leakage at the endpoint level." },
+  { key: "threat",     agent: "hushai", prompt: "Threat model: trust boundary changes, new abuse paths, secrets handling, audit trail completeness, privilege escalation surfaces." },
+];
+
+const findings = await parallel(LENSES.map(L => () =>
+  agent(
+    `Surface: ${surface}. Diff: ${diffRef}. Project: ${project}. Your lens: ${L.prompt} Return the schema. Default to listing findings if uncertain — we tolerate false positives in this gate.`,
+    { schema: FINDING_SCHEMA, label: `find:${L.key}`, agentType: L.agent, phase: "Find" },
+  ).then(f => ({ lens: L.key, findings: f.findings ?? [] }))
+));
+
+const allFindings = findings.filter(Boolean).flatMap(f => f.findings.map(x => ({ ...x, lens: f.lens })));
+log(`${allFindings.length} raw findings across 3 lenses.`);
+
+phase("Refute");
+const refuters = ["ira", "joab", "hushai"];
+const verified = await parallel(allFindings.map(F => () =>
+  parallel(refuters.map(r => () =>
+    agent(
+      `Surface: ${surface}. Finding: "${F.title}" — ${F.rationale}. Try to REFUTE this finding. Default refuted=true if uncertain — we want only confirmed findings to block.`,
+      { schema: REFUTE_SCHEMA, label: `refute:${r}:${F.title.slice(0,20)}`, agentType: r, phase: "Refute" },
+    )
+  )).then(votes => {
+    const valid = votes.filter(Boolean);
+    const refutedCount = valid.filter(v => v.refuted).length;
+    return { finding: F, refuted_votes: refutedCount, confirmed: refutedCount <= 1 };
+  })
+));
+
+const confirmed = verified.filter(v => v.confirmed).map(v => v.finding);
+const blockingSeverities = ["high", "critical"];
+const blockers = confirmed.filter(f => blockingSeverities.includes(f.severity));
+
+phase("Decide");
+return {
+  surface,
+  diff_ref: diffRef,
+  total_findings_raw: allFindings.length,
+  confirmed_findings: confirmed,
+  blockers,
+  decision: blockers.length === 0 ? "pass" : "block",
+  summary: blockers.length === 0
+    ? `Security gate PASS. ${confirmed.length} non-blocking findings (info/low/medium). Merge allowed.`
+    : `Security gate BLOCK. ${blockers.length} confirmed high/critical findings on ${surface}. Address before merge.`,
+};