@plures/praxis 1.2.12 → 1.2.41

package/dist/node/cli/index.js

@@ -689,7 +689,7 @@ cloudCmd.command("usage").description("View cloud usage metrics").action(async (
 });
 program.command("verify <type>").description("Verify project implementation (e.g., implementation)").option("-d, --detailed", "Show detailed analysis").action(async (type, options) => {
   try {
-    const { verify } = await import("../verify-KLJRXVJS.js");
+    const { verify } = await import("../verify-7VZRP2WS.js");
     await verify(type, options);
   } catch (error) {
     console.error("Error verifying:", error);
@@ -698,7 +698,7 @@ program.command("verify <type>").description("Verify project implementation (e.g
 });
 program.command("validate").description("Validate contract coverage for rules and constraints").option("--output <format>", "Output format (console, json, sarif)", "console").option("--strict", "Exit with error if contracts are missing", false).option("--registry <path>", "Path to registry module").option("--tests", "Check for tests for each rule/constraint", true).option("--spec", "Check for specs for each rule/constraint", true).option("--emit-facts", "Emit ContractMissing facts JSON payload", false).option("--gap-output <file>", "Write contract-gap payload to file").option("--ledger <dir>", "Write logic ledger snapshots to directory").option("--author <name>", "Author name for ledger entries", "system").action(async (options) => {
   try {
-    const { validateCommand } = await import("../validate-CNHUULQE.js");
+    const { validateCommand } = await import("../validate-EN3M4FUR.js");
     await validateCommand(options);
   } catch (error) {
     console.error("Error validating contracts:", error);
@@ -714,4 +714,41 @@ program.command("reverse").description("Reverse engineer contracts from existing
     process.exit(1);
   }
 });
+var conversationsCmd = program.command("conversations").description("Conversation ingestion subsystem (capture -> redact -> normalize -> classify -> emit)");
+conversationsCmd.command("capture").description("Capture a conversation from input").option("-i, --input <file>", "Input conversation file").option("-o, --output <file>", "Output file for captured conversation").action(async (options) => {
+  try {
+    const { captureCommand } = await import("../conversations-KQBXTP3N.js");
+    await captureCommand(options);
+  } catch (error) {
+    console.error("Error capturing conversation:", error);
+    process.exit(1);
+  }
+});
+conversationsCmd.command("push").description("Process conversation through pipeline (redact -> normalize)").requiredOption("-i, --input <file>", "Input conversation file").option("-o, --output <file>", "Output file for processed conversation").option("--skip-redaction", "Skip PII redaction", false).option("--skip-normalization", "Skip normalization", false).action(async (options) => {
+  try {
+    const { pushCommand } = await import("../conversations-KQBXTP3N.js");
+    await pushCommand(options);
+  } catch (error) {
+    console.error("Error processing conversation:", error);
+    process.exit(1);
+  }
+});
+conversationsCmd.command("classify").description("Classify conversation and generate candidate").requiredOption("-i, --input <file>", "Input conversation file").option("-o, --output <file>", "Output file for candidate").action(async (options) => {
+  try {
+    const { classifyCommand } = await import("../conversations-KQBXTP3N.js");
+    await classifyCommand(options);
+  } catch (error) {
+    console.error("Error classifying conversation:", error);
+    process.exit(1);
+  }
+});
+conversationsCmd.command("emit").description("Emit candidate to destination (fs or github)").requiredOption("-i, --input <file>", "Input candidate file").requiredOption("-e, --emitter <type>", "Emitter type (fs, github)").option("--output-dir <dir>", "Output directory (for fs emitter)", "./output/candidates").option("--owner <owner>", "GitHub repository owner (for github emitter)").option("--repo <repo>", "GitHub repository name (for github emitter)").option("--token <token>", "GitHub token (for github emitter)").option("--dry-run", "Dry run mode (no actual emission)", false).option("--commit-intent", "REQUIRED: Explicit commit intent for GitHub emission", false).action(async (options) => {
+  try {
+    const { emitCommand } = await import("../conversations-KQBXTP3N.js");
+    await emitCommand(options);
+  } catch (error) {
+    console.error("Error emitting candidate:", error);
+    process.exit(1);
+  }
+});
 program.parse();

package/dist/node/cloud/index.d.cts

@@ -1,4 +1,4 @@
-import { b as PraxisFact, a as PraxisEvent } from '../protocol-Qek7ebBl.cjs';
+import { b as PraxisFact, a as PraxisEvent } from '../protocol-BocKczNv.cjs';
 
 /**
  * Cloud Relay Types

package/dist/node/cloud/index.d.ts

@@ -1,4 +1,4 @@
-import { b as PraxisFact, a as PraxisEvent } from '../protocol-Qek7ebBl.js';
+import { b as PraxisFact, a as PraxisEvent } from '../protocol-BocKczNv.js';
 
 /**
  * Cloud Relay Types

package/dist/node/components/index.d.cts

@@ -1,5 +1,5 @@
-import { T as TerminalAdapter } from '../terminal-adapter-BQSIF5bf.cjs';
-export { c as createTerminalAdapter } from '../terminal-adapter-BQSIF5bf.cjs';
+import { T as TerminalAdapter } from '../terminal-adapter-Db-snPJ3.cjs';
+export { c as createTerminalAdapter } from '../terminal-adapter-Db-snPJ3.cjs';
 import '../schema.cjs';
 import '@plures/pluresdb/local-first';
 

package/dist/node/components/index.d.ts

@@ -1,5 +1,5 @@
-import { T as TerminalAdapter } from '../terminal-adapter-B-UK_Vdz.js';
-export { c as createTerminalAdapter } from '../terminal-adapter-B-UK_Vdz.js';
+import { T as TerminalAdapter } from '../terminal-adapter-CvIvgTo4.js';
+export { c as createTerminalAdapter } from '../terminal-adapter-CvIvgTo4.js';
 import '../schema.js';
 import '@plures/pluresdb/local-first';
 

package/dist/node/conversations-KQBXTP3N.js

@@ -0,0 +1,596 @@
+import "./chunk-QGM4M3NI.js";
+
+// src/cli/commands/conversations.ts
+import { promises as fs2 } from "fs";
+
+// src/conversations/capture.ts
+import { randomUUID } from "crypto";
+function captureConversation(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: randomUUID(),
+    timestamp: now,
+    turns: input.turns.map((turn) => ({
+      role: turn.role,
+      content: turn.content,
+      timestamp: turn.timestamp || now,
+      metadata: {}
+    })),
+    metadata: {
+      source: input.metadata?.source || "unknown",
+      userId: input.metadata?.userId,
+      sessionId: input.metadata?.sessionId,
+      tags: input.metadata?.tags || []
+    },
+    redacted: false,
+    normalized: false,
+    classified: false
+  };
+}
+function loadConversation(json) {
+  const data = JSON.parse(json);
+  if (!data.id || !data.timestamp || !data.turns || !data.metadata) {
+    throw new Error("Invalid conversation JSON: missing required fields");
+  }
+  return data;
+}
+
+// src/conversations/redact.ts
+var PII_PATTERNS = [
+  // Email addresses
+  { pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, replacement: "[EMAIL_REDACTED]" },
+  // Phone numbers (simple patterns)
+  { pattern: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g, replacement: "[PHONE_REDACTED]" },
+  // Credit card numbers (basic pattern - intentionally broad for safety)
+  { pattern: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g, replacement: "[CARD_REDACTED]" },
+  // SSN pattern
+  { pattern: /\b\d{3}-\d{2}-\d{4}\b/g, replacement: "[SSN_REDACTED]" },
+  // IP addresses (basic pattern - may match invalid IPs like 999.999.999.999)
+  { pattern: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, replacement: "[IP_REDACTED]" }
+];
+function redactText(text) {
+  let redacted = text;
+  for (const { pattern, replacement } of PII_PATTERNS) {
+    redacted = redacted.replace(pattern, replacement);
+  }
+  return redacted;
+}
+function redactConversation(conversation) {
+  return {
+    ...conversation,
+    turns: conversation.turns.map((turn) => ({
+      ...turn,
+      content: redactText(turn.content)
+    })),
+    metadata: {
+      ...conversation.metadata,
+      // Redact userId if it looks like an email
+      userId: conversation.metadata.userId ? redactText(conversation.metadata.userId) : void 0
+    },
+    redacted: true
+  };
+}
+
+// src/conversations/normalize.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\t/g, "  ").replace(/\n{3,}/g, "\n\n").trim();
+}
+function normalizeCodeBlocks(text) {
+  return text.replace(/```(\w+)?\n/g, (_match, lang) => {
+    return lang ? `\`\`\`${lang.toLowerCase()}
+` : "```\n";
+  });
+}
+function normalizeTurn(content) {
+  let normalized = content;
+  normalized = normalizeWhitespace(normalized);
+  normalized = normalizeCodeBlocks(normalized);
+  return normalized;
+}
+function normalizeConversation(conversation) {
+  return {
+    ...conversation,
+    turns: conversation.turns.map((turn) => ({
+      ...turn,
+      content: normalizeTurn(turn.content)
+    })),
+    normalized: true
+  };
+}
+
+// src/conversations/classify.ts
+var CLASSIFICATION_RULES = [
+  {
+    category: "bug-report",
+    keywords: ["bug", "error", "crash", "broken", "issue", "problem", "fail", "exception"],
+    weight: 1
+  },
+  {
+    category: "feature-request",
+    keywords: ["feature", "enhancement", "add", "support", "implement", "would like", "could you"],
+    weight: 1
+  },
+  {
+    category: "question",
+    keywords: ["how", "what", "why", "when", "where", "?", "help", "question"],
+    weight: 0.8
+  },
+  {
+    category: "documentation",
+    keywords: ["docs", "documentation", "readme", "guide", "tutorial", "example"],
+    weight: 0.9
+  },
+  {
+    category: "performance",
+    keywords: ["slow", "performance", "optimize", "speed", "memory", "cpu"],
+    weight: 1
+  }
+];
+function extractKeywords(text) {
+  return text.toLowerCase().split(/\s+/).map((word) => word.replace(/[^\w]/g, "")).filter((word) => word.length > 2);
+}
+function calculateScores(conversation) {
+  const scores = {};
+  const allContent = conversation.turns.map((t) => t.content).join(" ");
+  const keywords = extractKeywords(allContent);
+  const keywordSet = new Set(keywords);
+  for (const rule of CLASSIFICATION_RULES) {
+    let matchCount = 0;
+    for (const keyword of rule.keywords) {
+      if (keywordSet.has(keyword.toLowerCase())) {
+        matchCount++;
+      }
+    }
+    if (matchCount > 0) {
+      scores[rule.category] = matchCount / rule.keywords.length * rule.weight;
+    }
+  }
+  return scores;
+}
+function classifyConversation(conversation) {
+  const scores = calculateScores(conversation);
+  let bestCategory = "unknown";
+  let bestScore = 0;
+  for (const [category, score] of Object.entries(scores)) {
+    if (score > bestScore) {
+      bestScore = score;
+      bestCategory = category;
+    }
+  }
+  const classification = {
+    category: bestCategory,
+    confidence: Math.min(bestScore, 1),
+    tags: Object.entries(scores).filter(([_, score]) => score > 0.3).map(([category]) => category)
+  };
+  return {
+    ...conversation,
+    classification,
+    classified: true
+  };
+}
+
+// src/conversations/candidates.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function generateCandidate(conversation) {
+  if (!conversation.classified || !conversation.classification) {
+    throw new Error("Conversation must be classified before generating candidates");
+  }
+  const { classification } = conversation;
+  let type = "documentation";
+  if (classification.category === "bug-report") {
+    type = "github-issue";
+  } else if (classification.category === "feature-request") {
+    type = "github-issue";
+  } else if (classification.category === "documentation") {
+    type = "documentation";
+  }
+  const firstUserTurn = conversation.turns.find((t) => t.role === "user");
+  if (!firstUserTurn) {
+    return null;
+  }
+  const title = generateTitle(firstUserTurn.content, classification.category);
+  const body = generateBody(conversation);
+  let priority = "medium";
+  if (classification.category === "bug-report" && (classification.confidence ?? 0) > 0.7) {
+    priority = "high";
+  }
+  const labels = [...new Set([classification.category, ...classification.tags || []].filter((label) => label !== void 0))];
+  return {
+    id: randomUUID2(),
+    conversationId: conversation.id,
+    type,
+    title,
+    body,
+    metadata: {
+      priority,
+      labels,
+      source: {
+        conversationId: conversation.id,
+        timestamp: conversation.timestamp
+      }
+    },
+    emitted: false
+  };
+}
+function generateTitle(content, category) {
+  const firstLine = content.split("\n")[0].trim();
+  const firstSentence = firstLine.split(/[.!?]/)[0].trim();
+  let title = firstSentence.substring(0, 80);
+  if (firstSentence.length > 80) {
+    title += "...";
+  }
+  if (category && category !== "unknown") {
+    const prefix = category.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
+    title = `[${prefix}] ${title}`;
+  }
+  return title;
+}
+function generateBody(conversation) {
+  const parts = [];
+  parts.push("## Conversation Summary\n");
+  for (const turn of conversation.turns) {
+    const roleName = turn.role.charAt(0).toUpperCase() + turn.role.slice(1);
+    parts.push(`**${roleName}:**
+${turn.content}
+`);
+  }
+  if (conversation.classification) {
+    parts.push(`
+## Classification
+`);
+    parts.push(`- Category: ${conversation.classification.category}`);
+    parts.push(`- Confidence: ${(conversation.classification.confidence || 0).toFixed(2)}`);
+    if (conversation.classification.tags && conversation.classification.tags.length > 0) {
+      parts.push(`- Tags: ${conversation.classification.tags.join(", ")}`);
+    }
+  }
+  parts.push(`
+---
+*Generated from conversation ${conversation.id}*`);
+  return parts.join("\n");
+}
+
+// src/conversations/gate.ts
+function gateMinimumLength(candidate) {
+  const minLength = 50;
+  const passed = candidate.body.length >= minLength;
+  return {
+    name: "minimum-length",
+    passed,
+    message: passed ? "Content meets minimum length requirement" : `Content too short (${candidate.body.length} < ${minLength} chars)`
+  };
+}
+function gateValidTitle(candidate) {
+  const passed = candidate.title.length > 10 && candidate.title.length < 200;
+  return {
+    name: "valid-title",
+    passed,
+    message: passed ? "Title is valid" : "Title length must be between 10 and 200 characters"
+  };
+}
+function gateNotDuplicate(_candidate) {
+  return {
+    name: "not-duplicate",
+    passed: true,
+    message: "Duplicate check passed (stub)"
+  };
+}
+function gateHasMetadata(candidate) {
+  const hasLabels = !!(candidate.metadata.labels && candidate.metadata.labels.length > 0);
+  const hasPriority = !!candidate.metadata.priority;
+  const passed = hasLabels && hasPriority;
+  return {
+    name: "has-metadata",
+    passed,
+    message: passed ? "Candidate has required metadata" : "Missing labels or priority in metadata"
+  };
+}
+function applyGates(candidate) {
+  const gates = [
+    gateMinimumLength(candidate),
+    gateValidTitle(candidate),
+    gateNotDuplicate(candidate),
+    gateHasMetadata(candidate)
+  ];
+  const allPassed = gates.every((g) => g.passed);
+  const failedGates = gates.filter((g) => !g.passed);
+  const gateStatus = {
+    passed: allPassed,
+    reason: allPassed ? "All gates passed" : `Failed gates: ${failedGates.map((g) => g.name).join(", ")}`,
+    gates
+  };
+  return {
+    ...candidate,
+    gateStatus
+  };
+}
+function candidatePassed(candidate) {
+  return candidate.gateStatus?.passed || false;
+}
+
+// src/conversations/emitters/fs.ts
+import { promises as fs } from "fs";
+import path from "path";
+async function emitToFS(candidate, options) {
+  const { outputDir, dryRun = false } = options;
+  if (dryRun) {
+    console.log(`[DRY RUN] Would emit candidate ${candidate.id} to ${outputDir}`);
+    return {
+      ...candidate,
+      emitted: true,
+      emissionResult: {
+        success: true,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        externalId: `fs://${outputDir}/${candidate.id}.json`
+      }
+    };
+  }
+  try {
+    await fs.mkdir(outputDir, { recursive: true });
+    const filename = `${candidate.id}.json`;
+    const filepath = path.join(outputDir, filename);
+    await fs.writeFile(filepath, JSON.stringify(candidate, null, 2), "utf-8");
+    const result = {
+      success: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      externalId: `fs://${filepath}`
+    };
+    return {
+      ...candidate,
+      emitted: true,
+      emissionResult: result
+    };
+  } catch (error) {
+    const result = {
+      success: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+    return {
+      ...candidate,
+      emitted: false,
+      emissionResult: result
+    };
+  }
+}
+
+// src/conversations/emitters/github.ts
+async function emitToGitHub(candidate, options) {
+  const { owner, repo, token, dryRun = false, commitIntent = false } = options;
+  if (!commitIntent) {
+    const result = {
+      success: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: "GATE FAILURE: commit_intent must be explicitly set to true for GitHub emission"
+    };
+    console.error(`[GATE BLOCKED] ${result.error}`);
+    return {
+      ...candidate,
+      emitted: false,
+      emissionResult: result
+    };
+  }
+  if (dryRun) {
+    console.log(`[DRY RUN] Would create GitHub issue in ${owner}/${repo}`);
+    console.log(`Title: ${candidate.title}`);
+    console.log(`Labels: ${candidate.metadata.labels?.join(", ") || "none"}`);
+    return {
+      ...candidate,
+      emitted: true,
+      emissionResult: {
+        success: true,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        externalId: `github://${owner}/${repo}/issues/DRY_RUN`
+      }
+    };
+  }
+  try {
+    if (!owner || !repo) {
+      throw new Error("GitHub owner and repo are required");
+    }
+    if (!token) {
+      throw new Error("GitHub token is required for emission");
+    }
+    const issueData = {
+      title: candidate.title,
+      body: candidate.body,
+      labels: candidate.metadata.labels || [],
+      assignees: candidate.metadata.assignees || []
+    };
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/issues`, {
+      method: "POST",
+      headers: {
+        "Authorization": `token ${token}`,
+        "Accept": "application/vnd.github.v3+json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(issueData)
+    });
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(`GitHub API error: ${errorData.message || response.statusText}`);
+    }
+    const issue = await response.json();
+    const result = {
+      success: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      externalId: `github://${owner}/${repo}/issues/${issue.number}`
+    };
+    console.log(`\u2713 Created GitHub issue #${issue.number}: ${issue.html_url}`);
+    return {
+      ...candidate,
+      emitted: true,
+      emissionResult: result
+    };
+  } catch (error) {
+    const result = {
+      success: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+    console.error(`\u2717 Failed to create GitHub issue: ${result.error}`);
+    return {
+      ...candidate,
+      emitted: false,
+      emissionResult: result
+    };
+  }
+}
+
+// src/cli/commands/conversations.ts
+async function captureCommand(options) {
+  console.log("\u{1F4DD} Capturing conversation...");
+  let conversation;
+  if (options.input) {
+    const content = await fs2.readFile(options.input, "utf-8");
+    conversation = loadConversation(content);
+    console.log(`\u2713 Loaded conversation from ${options.input}`);
+  } else {
+    conversation = captureConversation({
+      turns: [
+        { role: "user", content: "Hello, I have a question about the feature" },
+        { role: "assistant", content: "Sure, I'd be happy to help!" }
+      ],
+      metadata: {
+        source: "cli"
+      }
+    });
+    console.log("\u2713 Created sample conversation");
+  }
+  if (options.output) {
+    await fs2.writeFile(
+      options.output,
+      JSON.stringify(conversation, null, 2),
+      "utf-8"
+    );
+    console.log(`\u2713 Saved to ${options.output}`);
+  } else {
+    console.log(JSON.stringify(conversation, null, 2));
+  }
+}
+async function pushCommand(options) {
+  console.log("\u{1F504} Processing conversation through pipeline...");
+  const content = await fs2.readFile(options.input, "utf-8");
+  let conversation = loadConversation(content);
+  console.log(`\u2713 Loaded conversation ${conversation.id}`);
+  if (!options.skipRedaction) {
+    conversation = redactConversation(conversation);
+    console.log("\u2713 Redacted PII");
+  }
+  if (!options.skipNormalization) {
+    conversation = normalizeConversation(conversation);
+    console.log("\u2713 Normalized content");
+  }
+  if (options.output) {
+    await fs2.writeFile(
+      options.output,
+      JSON.stringify(conversation, null, 2),
+      "utf-8"
+    );
+    console.log(`\u2713 Saved to ${options.output}`);
+  } else {
+    console.log(JSON.stringify(conversation, null, 2));
+  }
+}
+async function classifyCommand(options) {
+  console.log("\u{1F3F7}\uFE0F  Classifying conversation...");
+  const content = await fs2.readFile(options.input, "utf-8");
+  let conversation = loadConversation(content);
+  console.log(`\u2713 Loaded conversation ${conversation.id}`);
+  if (!conversation.redacted) {
+    conversation = redactConversation(conversation);
+    console.log("\u2713 Applied redaction");
+  }
+  if (!conversation.normalized) {
+    conversation = normalizeConversation(conversation);
+    console.log("\u2713 Applied normalization");
+  }
+  conversation = classifyConversation(conversation);
+  console.log(`\u2713 Classified as: ${conversation.classification?.category} (confidence: ${conversation.classification?.confidence?.toFixed(2)})`);
+  const candidate = generateCandidate(conversation);
+  if (!candidate) {
+    console.error("\u2717 Failed to generate candidate");
+    process.exit(1);
+  }
+  console.log(`\u2713 Generated candidate: ${candidate.title}`);
+  const gatedCandidate = applyGates(candidate);
+  console.log(`
+\u{1F4CB} Gate Results:`);
+  for (const gate of gatedCandidate.gateStatus?.gates || []) {
+    const icon = gate.passed ? "\u2713" : "\u2717";
+    console.log(`  ${icon} ${gate.name}: ${gate.message}`);
+  }
+  const passed = candidatePassed(gatedCandidate);
+  console.log(`
+${passed ? "\u2713 All gates passed" : "\u2717 Some gates failed"}`);
+  if (options.output) {
+    await fs2.writeFile(
+      options.output,
+      JSON.stringify(gatedCandidate, null, 2),
+      "utf-8"
+    );
+    console.log(`\u2713 Saved candidate to ${options.output}`);
+  } else {
+    console.log("\n" + JSON.stringify(gatedCandidate, null, 2));
+  }
+}
+async function emitCommand(options) {
+  console.log("\u{1F4E4} Emitting candidate...");
+  const content = await fs2.readFile(options.input, "utf-8");
+  const candidate = JSON.parse(content);
+  console.log(`\u2713 Loaded candidate ${candidate.id}`);
+  if (!candidatePassed(candidate)) {
+    console.error("\u2717 Candidate did not pass gates, refusing to emit");
+    console.error(`  Reason: ${candidate.gateStatus?.reason}`);
+    process.exit(1);
+  }
+  let result;
+  if (options.emitter === "fs") {
+    const outputDir = options.outputDir || "./output/candidates";
+    result = await emitToFS(candidate, {
+      outputDir,
+      dryRun: options.dryRun
+    });
+    if (result.emissionResult?.success) {
+      console.log(`\u2713 Emitted to filesystem: ${result.emissionResult.externalId}`);
+    } else {
+      console.error(`\u2717 Emission failed: ${result.emissionResult?.error}`);
+      process.exit(1);
+    }
+  } else if (options.emitter === "github") {
+    if (!options.owner || !options.repo) {
+      console.error("\u2717 GitHub emitter requires --owner and --repo");
+      process.exit(1);
+    }
+    if (!options.commitIntent) {
+      console.error("");
+      console.error("\u26D4 GATE BLOCKED: commit_intent=false");
+      console.error("");
+      console.error("The GitHub emitter is HARD GATED by the --commit-intent flag.");
+      console.error("This prevents accidental issue creation.");
+      console.error("");
+      console.error("To emit to GitHub, add: --commit-intent");
+      console.error("");
+      process.exit(1);
+    }
+    result = await emitToGitHub(candidate, {
+      owner: options.owner,
+      repo: options.repo,
+      token: options.token,
+      dryRun: options.dryRun,
+      commitIntent: options.commitIntent
+    });
+    if (result.emissionResult?.success) {
+      console.log(`\u2713 Emitted to GitHub: ${result.emissionResult.externalId}`);
+    } else {
+      console.error(`\u2717 Emission failed: ${result.emissionResult?.error}`);
+      process.exit(1);
+    }
+  }
+}
+export {
+  captureCommand,
+  classifyCommand,
+  emitCommand,
+  pushCommand
+};

package/dist/node/{engine-2DQBKBJC.js → engine-7CXQV6RC.js}

@@ -1,7 +1,7 @@
 import {
   LogicEngine,
   createPraxisEngine
-} from "./chunk-VOMLVI6V.js";
+} from "./chunk-BBP2F7TT.js";
 import "./chunk-QGM4M3NI.js";
 export {
   LogicEngine,