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

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

@@ -1,219 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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

@@ -1,37 +0,0 @@
-/**
- * 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 };
-}