newtype-profile 1.0.13 → 1.0.16

package/dist/cli/index.js

@@ -2253,7 +2253,7 @@ var require_picocolors = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "newtype-profile",
-    version: "1.0.13",
+    version: "1.0.16",
     description: "AI Agent Collaboration System for Content Creation - Based on oh-my-opencode",
     main: "dist/index.js",
     types: "dist/index.d.ts",

package/dist/hooks/chief-orchestrator/confidence-router.d.ts

@@ -1,13 +1,16 @@
 /**
- * Confidence-based routing for fact-check results
+ * Confidence-based routing for agent outputs
  *
- * Parses confidence scores from fact-checker output and generates
+ * Parses confidence scores from agent outputs and generates
  * routing recommendations for the orchestrator.
  */
+export type AgentType = "fact-checker" | "researcher" | "writer" | "editor";
+export type Recommendation = "pass" | "polish" | "rewrite" | "escalate";
 export interface ConfidenceResult {
     confidence: number | null;
-    recommendation: "pass" | "polish" | "rewrite" | null;
+    recommendation: Recommendation | null;
     directive: string | null;
+    agentType?: AgentType;
 }
 /**
  * Extract confidence score from fact-checker output
@@ -18,15 +21,44 @@ export declare function extractConfidence(output: string): number | null;
  * Determine routing recommendation based on confidence score
  */
 export declare function getRecommendation(confidence: number): "pass" | "polish" | "rewrite";
+/**
+ * Get current rewrite attempt count for a session and agent type
+ */
+export declare function getRewriteAttempts(sessionId: string, agentType: AgentType): number;
+/**
+ * Increment and return the new rewrite attempt count for a session and agent type
+ */
+export declare function incrementRewriteAttempts(sessionId: string, agentType: AgentType): number;
+/**
+ * Clear rewrite attempts for a session (call on session cleanup)
+ */
+export declare function clearRewriteAttempts(sessionId: string): void;
 /**
  * Build routing directive for Chief based on confidence
  */
-export declare function buildConfidenceDirective(confidence: number, sessionId: string): string;
+export declare function buildConfidenceDirective(confidence: number, sessionId: string, agentType?: AgentType): string;
+/**
+ * Build escalate directive when max rewrite attempts exceeded
+ */
+export declare function buildEscalateDirective(confidence: number, attempts: number): string;
 /**
  * Analyze fact-check output and generate routing result
+ * Tracks rewrite attempts and escalates after MAX_REWRITE_ATTEMPTS
  */
 export declare function analyzeFactCheckOutput(output: string, sessionId: string): ConfidenceResult;
+/**
+ * Generic analyzer for any agent type with confidence scoring
+ */
+export declare function analyzeAgentOutput(output: string, sessionId: string, agentType: AgentType): ConfidenceResult;
 /**
  * Check if output is from a fact-check task
  */
 export declare function isFactCheckOutput(output: string): boolean;
+/**
+ * Detect agent type from output content
+ */
+export declare function detectAgentType(output: string, category?: string): AgentType | null;
+/**
+ * Check if output contains a confidence score
+ */
+export declare function hasConfidenceScore(output: string): boolean;

package/dist/index.js

@@ -22894,6 +22894,8 @@ function clearTrackerForSession(sessionId) {
 }
 
 // src/hooks/chief-orchestrator/confidence-router.ts
+var MAX_REWRITE_ATTEMPTS = 2;
+var rewriteAttempts = new Map;
 function extractConfidence(output) {
   const match = output.match(/\*\*CONFIDENCE:\s*(\d+\.?\d*)\*\*/i);
   if (match) {
@@ -22913,55 +22915,229 @@ function getRecommendation(confidence) {
     return "rewrite";
   }
 }
-function buildConfidenceDirective(confidence, sessionId) {
+function incrementRewriteAttempts(sessionId, agentType) {
+  let sessionMap = rewriteAttempts.get(sessionId);
+  if (!sessionMap) {
+    sessionMap = new Map;
+    rewriteAttempts.set(sessionId, sessionMap);
+  }
+  const current = sessionMap.get(agentType) ?? 0;
+  const next = current + 1;
+  sessionMap.set(agentType, next);
+  return next;
+}
+function clearRewriteAttempts(sessionId) {
+  rewriteAttempts.delete(sessionId);
+}
+function buildConfidenceDirective(confidence, sessionId, agentType = "fact-checker") {
   const recommendation = getRecommendation(confidence);
   const confidencePercent = Math.round(confidence * 100);
+  const agentLabels = {
+    "fact-checker": "FACT-CHECK",
+    researcher: "RESEARCH",
+    writer: "DRAFT",
+    editor: "EDIT"
+  };
+  const label = agentLabels[agentType];
   switch (recommendation) {
     case "pass":
-      return `[FACT-CHECK PASSED]
+      return `[${label} PASSED]
 Confidence: ${confidencePercent}% (HIGH)
-Action: Content verified. Ready for delivery.`;
+Action: ${getPassAction(agentType)}`;
     case "polish":
-      return `[FACT-CHECK: NEEDS POLISH]
+      return `[${label}: NEEDS POLISH]
 Confidence: ${confidencePercent}% (MEDIUM)
-Action: Send to Editor for refinement.
+Action: ${getPolishAction(agentType)}
 
 REQUIRED: Call chief_task with:
-  category="editing"
-  prompt="Polish the content based on fact-check feedback. Address minor uncertainties while preserving verified claims."
+  category="${getPolishCategory(agentType)}"
+  prompt="${getPolishPrompt(agentType)}"
   resume="${sessionId}"`;
     case "rewrite":
-      return `[FACT-CHECK: NEEDS REWRITE]
+      return `[${label}: NEEDS REWRITE]
 Confidence: ${confidencePercent}% (LOW)
-Action: Significant issues found. Send back to Writer.
+Action: ${getRewriteAction(agentType)}
 
 REQUIRED: Call chief_task with:
-  category="writing"  
-  prompt="Rewrite the content addressing the fact-check issues. Focus on: [list specific issues from fact-check report]"
-  resume="${sessionId}"
-
-NOTE: Max 2 rewrite attempts. If still failing after 2 rewrites, escalate to user.`;
+  category="${getRewriteCategory(agentType)}"
+  prompt="${getRewritePrompt(agentType)}"
+  resume="${sessionId}"`;
   }
 }
-function analyzeFactCheckOutput(output, sessionId) {
+function getPassAction(agentType) {
+  switch (agentType) {
+    case "fact-checker":
+      return "Content verified. Ready for delivery.";
+    case "researcher":
+      return "Research complete. Proceed to writing.";
+    case "writer":
+      return "Draft complete. Send to editor.";
+    case "editor":
+      return "Edit complete. Send to fact-check.";
+  }
+}
+function getPolishAction(agentType) {
+  switch (agentType) {
+    case "fact-checker":
+      return "Send to Editor for refinement.";
+    case "researcher":
+      return "Needs additional research on specific gaps.";
+    case "writer":
+      return "Draft needs improvement before editing.";
+    case "editor":
+      return "Needs another editing pass.";
+  }
+}
+function getPolishCategory(agentType) {
+  switch (agentType) {
+    case "fact-checker":
+      return "editing";
+    case "researcher":
+      return "research";
+    case "writer":
+      return "writing";
+    case "editor":
+      return "editing";
+  }
+}
+function getPolishPrompt(agentType) {
+  switch (agentType) {
+    case "fact-checker":
+      return "Polish the content based on fact-check feedback. Address minor uncertainties while preserving verified claims.";
+    case "researcher":
+      return "Continue research on the identified gaps. Focus on: [list specific gaps from research report]";
+    case "writer":
+      return "Improve the draft addressing the identified issues. Focus on: [list specific issues]";
+    case "editor":
+      return "Continue editing to address remaining issues. Focus on: [list specific issues]";
+  }
+}
+function getRewriteAction(agentType) {
+  switch (agentType) {
+    case "fact-checker":
+      return "Significant issues found. Send back to Writer.";
+    case "researcher":
+      return "Research insufficient. Restart with different approach.";
+    case "writer":
+      return "Draft has fundamental issues. Needs major revision.";
+    case "editor":
+      return "Content not ready for editing. Send back to Writer.";
+  }
+}
+function getRewriteCategory(agentType) {
+  switch (agentType) {
+    case "fact-checker":
+      return "writing";
+    case "researcher":
+      return "research";
+    case "writer":
+      return "writing";
+    case "editor":
+      return "writing";
+  }
+}
+function getRewritePrompt(agentType) {
+  switch (agentType) {
+    case "fact-checker":
+      return "Rewrite the content addressing the fact-check issues. Focus on: [list specific issues from fact-check report]";
+    case "researcher":
+      return "Restart research with a different approach. Previous attempt was insufficient because: [list reasons]";
+    case "writer":
+      return "Rewrite the draft addressing fundamental issues. Focus on: [list specific issues]";
+    case "editor":
+      return "Content needs rewriting before editing. Issues: [list specific issues]";
+  }
+}
+function buildEscalateDirective(confidence, attempts) {
+  const confidencePercent = Math.round(confidence * 100);
+  return `[FACT-CHECK: ESCALATE TO USER]
+Confidence: ${confidencePercent}% (LOW)
+Rewrite attempts: ${attempts}/${MAX_REWRITE_ATTEMPTS} (LIMIT REACHED)
+
+\u26A0\uFE0F AUTOMATIC REWRITING HAS FAILED.
+
+The content has been rewritten ${attempts} times but still fails fact-check.
+This requires human judgment.
+
+ACTION REQUIRED:
+1. Present the fact-check issues to the user
+2. Ask for guidance on how to proceed
+3. Do NOT attempt another automatic rewrite
+
+Possible user decisions:
+- Provide additional sources or context
+- Accept lower confidence for this content
+- Manually revise the problematic claims
+- Abandon this content direction`;
+}
+function analyzeAgentOutput(output, sessionId, agentType) {
   const confidence = extractConfidence(output);
   if (confidence === null) {
     return {
       confidence: null,
       recommendation: null,
-      directive: null
+      directive: null,
+      agentType
     };
   }
-  const recommendation = getRecommendation(confidence);
-  const directive = buildConfidenceDirective(confidence, sessionId);
+  const baseRecommendation = getRecommendation(confidence);
+  if (baseRecommendation === "rewrite") {
+    const attempts = incrementRewriteAttempts(sessionId, agentType);
+    if (attempts > MAX_REWRITE_ATTEMPTS) {
+      return {
+        confidence,
+        recommendation: "escalate",
+        directive: buildEscalateDirective(confidence, attempts),
+        agentType
+      };
+    }
+    const directive2 = buildConfidenceDirective(confidence, sessionId, agentType) + `
+
+Rewrite attempt: ${attempts}/${MAX_REWRITE_ATTEMPTS}`;
+    return {
+      confidence,
+      recommendation: "rewrite",
+      directive: directive2,
+      agentType
+    };
+  }
+  const directive = buildConfidenceDirective(confidence, sessionId, agentType);
   return {
     confidence,
-    recommendation,
-    directive
-  };
+    recommendation: baseRecommendation,
+    directive,
+    agentType
+  };
+}
+function detectAgentType(output, category) {
+  if (category) {
+    const categoryToAgent = {
+      "fact-check": "fact-checker",
+      research: "researcher",
+      writing: "writer",
+      editing: "editor"
+    };
+    if (categoryToAgent[category]) {
+      return categoryToAgent[category];
+    }
+  }
+  const lowerOutput = output.toLowerCase();
+  if (lowerOutput.includes("fact-check") || lowerOutput.includes("verification") || output.includes("\u6838\u67E5")) {
+    return "fact-checker";
+  }
+  if (lowerOutput.includes("research") || lowerOutput.includes("findings") || lowerOutput.includes("sources found")) {
+    return "researcher";
+  }
+  if (lowerOutput.includes("edited") || lowerOutput.includes("polished") || lowerOutput.includes("revised")) {
+    return "editor";
+  }
+  if (lowerOutput.includes("draft") || lowerOutput.includes("wrote") || lowerOutput.includes("created content")) {
+    return "writer";
+  }
+  return null;
 }
-function isFactCheckOutput(output) {
-  return output.includes("CONFIDENCE:") || output.toLowerCase().includes("fact-check") || output.includes("\u6838\u67E5") || output.includes("verification");
+function hasConfidenceScore(output) {
+  return extractConfidence(output) !== null;
 }
 
 // src/hooks/chief-orchestrator/index.ts
@@ -23401,6 +23577,7 @@ function createChiefOrchestratorHook(ctx, options) {
         if (sessionInfo?.id) {
           sessions.delete(sessionInfo.id);
           clearTrackerForSession(sessionInfo.id);
+          clearRewriteAttempts(sessionInfo.id);
           log(`[${HOOK_NAME6}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
         }
         return;
@@ -23537,19 +23714,23 @@ ${buildOrchestratorReminder(boulderState.plan_name, progress, subagentSessionId)
           const summarized = summarizeOutput(output.output, { category });
           const formattedSummary = formatSummarizedOutput(summarized);
           let confidenceDirective = "";
-          if (isFactCheckOutput(output.output)) {
-            const confidenceResult = analyzeFactCheckOutput(output.output, subagentSessionId);
-            if (confidenceResult.directive) {
-              confidenceDirective = `
+          if (hasConfidenceScore(output.output)) {
+            const agentType = detectAgentType(output.output, category);
+            if (agentType) {
+              const confidenceResult = analyzeAgentOutput(output.output, subagentSessionId, agentType);
+              if (confidenceResult.directive) {
+                confidenceDirective = `
 
 ---
 ${confidenceResult.directive}
 ---`;
-              log(`[${HOOK_NAME6}] Confidence routing detected`, {
-                sessionID: input.sessionID,
-                confidence: confidenceResult.confidence,
-                recommendation: confidenceResult.recommendation
-              });
+                log(`[${HOOK_NAME6}] Confidence routing detected`, {
+                  sessionID: input.sessionID,
+                  agentType,
+                  confidence: confidenceResult.confidence,
+                  recommendation: confidenceResult.recommendation
+                });
+              }
             }
           }
           output.output = `${formattedSummary}
@@ -49231,7 +49412,23 @@ Always structure your findings as:
 - Use web search aggressively
 - Follow promising leads with targeted follow-up searches
 - When a source looks valuable, extract key quotes with attribution
-</Tool_Usage>`
+</Tool_Usage>
+
+<Confidence_Score>
+## Research Completeness Score (REQUIRED)
+After completing your research, you MUST end your response with a confidence score in this EXACT format:
+
+---
+**CONFIDENCE: X.XX**
+
+Where X.XX is a number between 0.00 and 1.00:
+- 0.90-1.00: Comprehensive coverage, multiple authoritative sources, all angles explored
+- 0.70-0.89: Good coverage, reliable sources, but some gaps or limited perspectives
+- 0.50-0.69: Partial coverage, mixed source quality, significant gaps remain
+- 0.00-0.49: Limited findings, unreliable sources, or topic poorly understood
+
+This score helps Chief decide if more research is needed before proceeding.
+</Confidence_Score>`
   };
 }
 var researcherAgent = createResearcherAgent();
@@ -49516,7 +49713,23 @@ You take research, source materials, and briefs, then produce structured, engagi
 - Done is better than perfect (that's editor's job)
 - Structure is your foundation \u2014 get that right first
 - When stuck, write badly first, then improve
-</Mindset>`
+</Mindset>
+
+<Confidence_Score>
+## Draft Quality Score (REQUIRED)
+After completing your draft, you MUST end your response with a confidence score in this EXACT format:
+
+---
+**CONFIDENCE: X.XX**
+
+Where X.XX is a number between 0.00 and 1.00:
+- 0.90-1.00: Complete draft, strong structure, well-grounded in sources, ready for editing
+- 0.70-0.89: Solid draft, minor gaps or rough sections, needs polish
+- 0.50-0.69: Partial draft, structural issues or missing sections, needs significant work
+- 0.00-0.49: Incomplete or problematic draft, fundamental issues with structure or content
+
+This score helps Chief decide if the draft needs revision before sending to Editor.
+</Confidence_Score>`
   };
 }
 var writerAgent = createWriterAgent();
@@ -49585,7 +49798,23 @@ You take drafts and make them excellent. You improve clarity, strengthen logic,
 - Every word should earn its place
 - Clarity > cleverness
 - Your job is to make the writer look good
-</Mindset>`
+</Mindset>
+
+<Confidence_Score>
+## Edit Quality Score (REQUIRED)
+After completing your edit, you MUST end your response with a confidence score in this EXACT format:
+
+---
+**CONFIDENCE: X.XX**
+
+Where X.XX is a number between 0.00 and 1.00:
+- 0.90-1.00: Polished and ready for publication, no remaining issues
+- 0.70-0.89: Good quality, minor improvements possible but acceptable
+- 0.50-0.69: Needs another pass, structural or clarity issues remain
+- 0.00-0.49: Significant problems, requires substantial revision or rewrite
+
+This score helps Chief decide if the content is ready for fact-check or needs more work.
+</Confidence_Score>`
   };
 }
 var editorAgent = createEditorAgent();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newtype-profile",
-  "version": "1.0.13",
+  "version": "1.0.16",
   "description": "AI Agent Collaboration System for Content Creation - Based on oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",