switchboard-cli 0.1.0-alpha.1 → 0.1.0-alpha.3

package/node_modules/@switchboard/projections/node_modules/@switchboard/core/src/claim-spread.ts

@@ -0,0 +1,219 @@
+import type { AuditedReceipt, ClaimSpread, ClaimSpreadVector } from "./types";
+import { claimSpreadSchema } from "./types";
+
+// ---------------------------------------------------------------------------
+// Claim/Receipt Spread — deterministic per-run drift measurement
+// ---------------------------------------------------------------------------
+//
+// Computes how far executor claims drift from the audited receipt's proven
+// evidence. Each axis is a normalized [0..1] signal derived solely from
+// governed fields on the AuditedReceipt.
+//
+// Design invariants:
+//   - Deterministic: same receipt → same spread, always
+//   - Read-only: never mutates the receipt or any governed object
+//   - Inspectable: every axis is individually readable
+//   - Narrow: no statistical smoothing, no Kalman, no analytics
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Axis weights — how much each signal contributes to the composite score
+// ---------------------------------------------------------------------------
+//
+// These are explicit and inspectable. They can be tuned later but must stay
+// deterministic (no learned weights, no per-project adaptation yet).
+// ---------------------------------------------------------------------------
+
+const AXIS_WEIGHTS: Record<keyof ClaimSpreadVector, number> = {
+  claim_mismatch_ratio: 0.30,     // heaviest — direct claim/proof gap
+  audit_burden: 0.15,             // audit had to intervene
+  residual_weight: 0.10,          // unresolved items carry forward
+  provenance_weakness: 0.15,      // proof chain quality
+  gate_distance: 0.15,            // how far gate is from acceptance
+  trace_failure_signal: 0.10,     // execution failed
+  budget_correction_weight: 0.05, // rework proportion
+};
+
+// ---------------------------------------------------------------------------
+// Provenance posture → weakness mapping
+// ---------------------------------------------------------------------------
+
+const PROVENANCE_WEAKNESS_MAP: Record<string, number> = {
+  captured: 0,
+  mixed: 0.25,
+  derived: 0.5,
+  reconstructed: 0.75,
+  unknown: 1,
+};
+
+// ---------------------------------------------------------------------------
+// Gate label → distance mapping
+// ---------------------------------------------------------------------------
+
+const GATE_DISTANCE_MAP: Record<string, number> = {
+  accepted: 0,
+  "accepted-with-cautions": 0.25,
+  "held-for-review": 0.5,
+  "blocked-missing-evidence": 0.75,
+  pending: 1,
+  "not-checked": 1,
+};
+
+// ---------------------------------------------------------------------------
+// Vector computation — each axis derived from receipt fields
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute the spread vector from an audited receipt.
+ *
+ * Every axis is derived deterministically from the receipt's governed fields.
+ * No external state, no randomness, no smoothing.
+ */
+export function computeSpreadVector(receipt: AuditedReceipt): ClaimSpreadVector {
+  const claims = receipt.claim_assessments;
+  const totalClaims = claims.length;
+
+  // --- claim_mismatch_ratio ---
+  // Claims that are NOT proven or supported (i.e., partial, inferred, unsubstantiated)
+  const weakClaims = claims.filter(
+    c => c.disposition !== "proven" && c.disposition !== "supported",
+  ).length;
+  const claim_mismatch_ratio = totalClaims > 0
+    ? weakClaims / totalClaims
+    : 0;
+
+  // --- audit_burden ---
+  // Audit findings (cautions + blockers), normalized: 0 = none, 1 = 5+
+  const auditFindings = receipt.audit_finding_count;
+  const audit_burden = Math.min(auditFindings / 5, 1);
+
+  // --- residual_weight ---
+  // Residuals relative to total claims — 0 = clean, 1 = residuals >= claims
+  const residual_weight = totalClaims > 0
+    ? Math.min(receipt.residual_count / totalClaims, 1)
+    : receipt.residual_count > 0 ? 1 : 0;
+
+  // --- provenance_weakness ---
+  const provenance_weakness = PROVENANCE_WEAKNESS_MAP[receipt.provenance_posture] ?? 1;
+
+  // --- gate_distance ---
+  const gate_distance = GATE_DISTANCE_MAP[receipt.gate_label] ?? 1;
+
+  // --- trace_failure_signal ---
+  const trace_failure_signal = receipt.trace_failure_phase !== "" ? 1 : 0;
+
+  // --- budget_correction_weight ---
+  const totalSteps =
+    receipt.budget_task_steps +
+    receipt.budget_verification_steps +
+    receipt.budget_correction_steps;
+  const budget_correction_weight = totalSteps > 0
+    ? receipt.budget_correction_steps / totalSteps
+    : 0;
+
+  return {
+    claim_mismatch_ratio,
+    audit_burden,
+    residual_weight,
+    provenance_weakness,
+    gate_distance,
+    trace_failure_signal,
+    budget_correction_weight,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Scalar score — weighted composite of the vector
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute the composite spread score from a spread vector.
+ *
+ * Returns a value in [0..1] where 0 = perfect alignment and 1 = maximum drift.
+ * The weights are explicit and inspectable (see AXIS_WEIGHTS above).
+ */
+export function computeSpreadScore(vector: ClaimSpreadVector): number {
+  let score = 0;
+  for (const [axis, weight] of Object.entries(AXIS_WEIGHTS) as Array<
+    [keyof ClaimSpreadVector, number]
+  >) {
+    score += vector[axis] * weight;
+  }
+  // Clamp to [0..1] — defensive, should already be in range
+  return Math.min(Math.max(score, 0), 1);
+}
+
+// ---------------------------------------------------------------------------
+// Basis derivation — human-readable explanation
+// ---------------------------------------------------------------------------
+
+function deriveSpreadBasis(vector: ClaimSpreadVector, score: number): string {
+  const parts: string[] = [];
+
+  if (vector.claim_mismatch_ratio > 0) {
+    parts.push(`claim mismatch ${(vector.claim_mismatch_ratio * 100).toFixed(0)}%`);
+  }
+  if (vector.gate_distance > 0) {
+    parts.push(`gate distance ${(vector.gate_distance * 100).toFixed(0)}%`);
+  }
+  if (vector.provenance_weakness > 0) {
+    parts.push(`provenance weakness ${(vector.provenance_weakness * 100).toFixed(0)}%`);
+  }
+  if (vector.audit_burden > 0) {
+    parts.push(`audit burden ${(vector.audit_burden * 100).toFixed(0)}%`);
+  }
+  if (vector.residual_weight > 0) {
+    parts.push(`residual weight ${(vector.residual_weight * 100).toFixed(0)}%`);
+  }
+  if (vector.trace_failure_signal > 0) {
+    parts.push("execution failure");
+  }
+  if (vector.budget_correction_weight > 0) {
+    parts.push(`correction effort ${(vector.budget_correction_weight * 100).toFixed(0)}%`);
+  }
+
+  if (parts.length === 0) {
+    return `Spread score ${score.toFixed(3)}: perfect alignment — no drift detected.`;
+  }
+
+  return `Spread score ${score.toFixed(3)}: ${parts.join(", ")}.`;
+}
+
+// ---------------------------------------------------------------------------
+// Primary builder — computeClaimSpread
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute the deterministic claim/receipt spread for a single run.
+ *
+ * Takes an AuditedReceipt (the governed source of truth) and returns
+ * a ClaimSpread containing the vector, scalar score, and basis.
+ *
+ * This never modifies the receipt. The spread is a derived observation.
+ */
+export function computeClaimSpread(receipt: AuditedReceipt): ClaimSpread {
+  const vector = computeSpreadVector(receipt);
+  const spread_score = computeSpreadScore(vector);
+  const spread_basis = deriveSpreadBasis(vector, spread_score);
+
+  return claimSpreadSchema.parse({
+    receipt_id: receipt.receipt_id,
+    dispatch_id: receipt.dispatch_id,
+    computed_at: new Date().toISOString(),
+    vector,
+    spread_score,
+    spread_basis,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Axis weight accessor — for inspection/testing
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns a copy of the axis weights used for composite scoring.
+ * Exposed for inspection and testing — not for runtime mutation.
+ */
+export function getAxisWeights(): Record<keyof ClaimSpreadVector, number> {
+  return { ...AXIS_WEIGHTS };
+}

package/node_modules/@switchboard/projections/node_modules/@switchboard/core/src/classifier.ts

@@ -0,0 +1,207 @@
+import type {
+  ActivationInput,
+  ComplexityClassification,
+  ComplexitySignals,
+  ComplexityVerdict,
+  ProcessMode,
+  SynthesizedSeed,
+} from "./types";
+import { complexityClassificationSchema } from "./types";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function compact(text: string) {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+// ---------------------------------------------------------------------------
+// Signal extraction
+// ---------------------------------------------------------------------------
+
+const SYSTEM_MARKERS = [
+  "slack", "jira", "github", "linear", "hubspot", "notion", "email",
+  "intercom", "salesforce", "zendesk", "asana", "trello", "figma",
+  "discord", "teams", "confluence", "airtable", "stripe", "twilio",
+  "postgres", "redis", "mongo", "firebase", "supabase", "aws", "gcp",
+];
+
+const CAPABILITY_MARKERS = [
+  "monitor", "recommend", "auto-create", "coordinate", "orchestrate",
+  "deploy", "pipeline", "analytics", "dashboard", "sync", "real-time",
+  "workflow", "automation", "marketplace", "collaboration",
+];
+
+const TRUST_MARKERS = [
+  "human review", "manual curation", "approval", "confirm",
+  "in the loop", "oversight", "permission",
+];
+
+const CONTRADICTION_PAIRS: [RegExp, RegExp][] = [
+  [/\ball\b.*\bfeatures?\b/i, /\bone\b.*\bdeveloper\b/i],
+  [/\bweb\b.*\band\b.*\bmobile\b/i, /\btwo weeks\b/i],
+  [/\bfull\b.*\bautonomous?\b/i, /\bhuman\b.*\breview\b/i],
+  [/\beverything\b/i, /\bv1\b|\bfirst\b|\bminimal\b/i],
+];
+
+function countImpliedSystems(text: string): number {
+  // Strip negated sentences — mentions in non-goals are not implied systems.
+  // "I do NOT want Jira integrations" does not mean the product uses Jira.
+  const affirmative = text
+    .replace(/I do (?:NOT|not) want[^.]*\./g, "")
+    .replace(/I (?:also )?do (?:NOT|not) want[^.]*\./g, "")
+    .replace(/(?:^|\.\s+)(?:No|not)\s+[^.]*integrations?[^.]*\./gi, "")
+    .replace(/(?:^|\.\s+)(?:No|not)\s+deep[^.]*\./gi, "")
+    .toLowerCase();
+
+  return SYSTEM_MARKERS.filter((s) => affirmative.includes(s)).length;
+}
+
+function countCapabilities(text: string): number {
+  const lower = text.toLowerCase();
+  return CAPABILITY_MARKERS.filter((c) => lower.includes(c)).length;
+}
+
+function hasTrustBoundary(text: string): boolean {
+  const lower = text.toLowerCase();
+  return TRUST_MARKERS.some((t) => lower.includes(t));
+}
+
+function countContradictions(raw: string, constraints: string): number {
+  const combined = `${raw} ${constraints}`;
+  let count = 0;
+  for (const [a, b] of CONTRADICTION_PAIRS) {
+    if (a.test(combined) && b.test(combined)) count++;
+  }
+  return count;
+}
+
+function hasResourceMismatch(raw: string, constraints: string): boolean {
+  const combined = compact(stripNegations(`${raw} ${constraints}`)).toLowerCase();
+  const hasAggressiveTimeline = /\b(two weeks|one week|weekend|one day|48 hours|24 hours)\b/.test(combined);
+  const hasLimitedTeam = /\b(one developer|solo|single person|just me|by myself)\b/.test(combined);
+  const systemCount = countImpliedSystems(combined);
+  const capCount = countCapabilities(combined);
+
+  if (hasAggressiveTimeline && (systemCount >= 3 || capCount >= 3)) return true;
+  if (hasLimitedTeam && (systemCount >= 4 || capCount >= 4)) return true;
+  return false;
+}
+
+function assessScopeBreadth(
+  systemCount: number,
+  capCount: number,
+  wordCount: number,
+): ComplexitySignals["scope_breadth"] {
+  if (systemCount >= 4 || capCount >= 4 || (systemCount >= 2 && capCount >= 3)) return "broad";
+  if (systemCount >= 2 || capCount >= 2 || wordCount > 150) return "moderate";
+  return "narrow";
+}
+
+// ---------------------------------------------------------------------------
+// Main classifier
+// ---------------------------------------------------------------------------
+
+function stripNegations(text: string): string {
+  return text
+    .replace(/I do (?:NOT|not) want[^.]*\./g, "")
+    .replace(/I (?:also )?do (?:NOT|not) want[^.]*\./g, "")
+    .replace(/(?:^|\.\s+)(?:No|not)\s+[^.]*integrations?[^.]*\./gi, "")
+    .replace(/(?:^|\.\s+)(?:No|not)\s+deep[^.]*\./gi, "")
+    .replace(/\bNo\s+\w+\s+analytics\b[^.]*\./gi, "")
+    .replace(/\(no [^)]+\)/gi, "");
+}
+
+function extractSignals(input: ActivationInput, seed: SynthesizedSeed): ComplexitySignals {
+  const combined = `${input.raw_idea} ${input.constraints}`;
+  const affirmativeCombined = stripNegations(combined);
+  const systemCount = countImpliedSystems(affirmativeCombined);
+  const capCount = countCapabilities(affirmativeCombined);
+  const wordCount = compact(input.raw_idea).split(/\s+/).length;
+
+  return {
+    implied_systems: systemCount,
+    missing_target_user: seed.target_user === "Solo builders shipping software.",
+    missing_workflow: seed.proposed_solution === "Needs further shaping.",
+    missing_trust_boundary: !hasTrustBoundary(combined),
+    scope_breadth: assessScopeBreadth(systemCount, capCount, wordCount),
+    contradiction_count: countContradictions(input.raw_idea, input.constraints),
+    resource_mismatch: hasResourceMismatch(input.raw_idea, input.constraints),
+  };
+}
+
+function classifyVerdict(signals: ComplexitySignals): ComplexityVerdict {
+  // Dangerous: multiple strong signals of over-scope
+  const dangerousSignals = [
+    signals.scope_breadth === "broad",
+    signals.implied_systems >= 4,
+    signals.resource_mismatch,
+    signals.contradiction_count >= 2,
+    signals.missing_target_user && signals.missing_workflow,
+  ].filter(Boolean).length;
+
+  if (dangerousSignals >= 2) return "dangerous";
+
+  // Simple: narrow scope, few systems, no contradictions, no resource mismatch.
+  // A simple idea can have low confidence (sparse input) — that's about seed quality,
+  // not scope complexity. The classifier judges scope, not seed completeness.
+  const simpleSignals = [
+    signals.scope_breadth === "narrow",
+    signals.implied_systems <= 1,
+    signals.contradiction_count === 0,
+    !signals.resource_mismatch,
+  ].filter(Boolean).length;
+
+  if (simpleSignals >= 4) return "simple";
+
+  return "standard";
+}
+
+function selectMode(verdict: ComplexityVerdict): ProcessMode {
+  switch (verdict) {
+    case "simple": return "minimal";
+    case "standard": return "structured";
+    case "dangerous": return "governance";
+  }
+}
+
+function buildRationale(verdict: ComplexityVerdict, signals: ComplexitySignals): string {
+  if (verdict === "simple") {
+    return "The idea is narrow, well-scoped, and ready to build. Minimal orchestration — Switchboard should mostly get out of the way.";
+  }
+
+  if (verdict === "dangerous") {
+    const reasons: string[] = [];
+    if (signals.scope_breadth === "broad") reasons.push("scope is very broad");
+    if (signals.implied_systems >= 4) reasons.push(`${signals.implied_systems} systems implied`);
+    if (signals.resource_mismatch) reasons.push("resource/time mismatch with stated scope");
+    if (signals.contradiction_count > 0) reasons.push(`${signals.contradiction_count} internal contradiction(s)`);
+    if (signals.missing_target_user) reasons.push("target user not specified");
+    if (signals.missing_workflow) reasons.push("core workflow not defined");
+    return `Governance mode required: ${reasons.join(", ")}. Must narrow scope before dispatch.`;
+  }
+
+  return "Standard complexity — full structured compilation with routing and bounded loop.";
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export function classifyComplexity(
+  input: ActivationInput,
+  seed: SynthesizedSeed,
+): ComplexityClassification {
+  const signals = extractSignals(input, seed);
+  const verdict = classifyVerdict(signals);
+  const mode = selectMode(verdict);
+  const rationale = buildRationale(verdict, signals);
+
+  return complexityClassificationSchema.parse({
+    verdict,
+    mode,
+    signals,
+    rationale,
+  });
+}

package/node_modules/@switchboard/projections/node_modules/@switchboard/core/src/claude-executor.ts

@@ -0,0 +1,37 @@
+/**
+ * Claude execution readiness + configuration.
+ * The actual SDK dispatch lives in apps/web where the SDK is installed.
+ */
+
+export type ExecutionResult = {
+  success: boolean;
+  raw_output: string;
+  structured_return: Record<string, unknown> | null;
+  /** How the structured_return was obtained:
+   *  - "parsed": extracted from structured output in the execution result
+   *  - "synthetic": built from unstructured output using heuristics (buildSyntheticReturn)
+   *  - null: no structured return (failure or empty output) */
+  structured_return_source: "parsed" | "synthetic" | null;
+  error: string | null;
+  model_used: string;
+  duration_ms: number;
+  /** Absolute path to the proof folder for this run, if created. */
+  proof_folder?: string;
+  /** Commands/tools detected during execution (for trace enrichment). */
+  commands_detected?: string[];
+};
+
+export function getExecutionModel(): string {
+  return process.env.SWITCHBOARD_EXECUTION_MODEL || "claude-sonnet-4-20250514";
+}
+
+export function isClaudeExecutionReady(): {
+  ready: boolean;
+  missing: string[];
+} {
+  const missing: string[] = [];
+  if (!process.env.ANTHROPIC_API_KEY) {
+    missing.push("ANTHROPIC_API_KEY");
+  }
+  return { ready: missing.length === 0, missing };
+}