titan-agent 6.5.2 → 7.0.0

package/assets/agent-skills/scientific-thinking-scholar-evaluation/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: scholar-evaluation
+description: Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback.
+origin: community
+---
+
+# Scholar Evaluation
+
+Use this skill to evaluate academic or scientific work with a repeatable rubric.
+
+## When to Use
+
+- Reviewing a research paper, proposal, thesis chapter, or literature review.
+- Checking whether claims are supported by cited evidence.
+- Evaluating methodology, study design, analysis, or limitations.
+- Comparing two or more papers for quality or relevance.
+- Producing structured feedback for revision.
+
+## Evaluation Scope
+
+Start by identifying the artifact:
+
+- empirical research paper
+- theoretical paper
+- technical report
+- systematic or narrative literature review
+- research proposal
+- thesis or dissertation chapter
+- conference abstract or short paper
+
+Then choose scope:
+
+- **comprehensive**: all rubric dimensions
+- **targeted**: one or two dimensions, such as method or citations
+- **comparative**: rank multiple works against the same rubric
+
+## Rubric
+
+Score each applicable dimension from 1 to 5:
+
+- 5: excellent; clear, rigorous, and publication-ready
+- 4: good; minor improvements needed
+- 3: adequate; meaningful gaps but usable
+- 2: weak; substantial revision needed
+- 1: poor; major validity or clarity problems
+
+Use `N/A` for dimensions that do not apply.
+
+### 1. Problem and Research Question
+
+- Is the problem clear and specific?
+- Is the contribution meaningful?
+- Are scope and assumptions explicit?
+- Does the question match the claimed contribution?
+
+### 2. Literature and Context
+
+- Is relevant prior work covered?
+- Does the work synthesize rather than merely list sources?
+- Are gaps accurately identified?
+- Are recent and foundational sources balanced?
+
+### 3. Methodology
+
+- Does the method answer the research question?
+- Are design choices justified?
+- Are variables, datasets, participants, or materials described clearly?
+- Could another researcher reproduce the work?
+- Are ethical and practical constraints acknowledged?
+
+### 4. Data and Evidence
+
+- Are data sources credible and appropriate?
+- Is sample size or corpus coverage adequate?
+- Are inclusion, exclusion, and preprocessing decisions documented?
+- Are missing data and bias risks discussed?
+
+### 5. Analysis
+
+- Are statistical, qualitative, or computational methods appropriate?
+- Are baselines and controls fair?
+- Are uncertainty, sensitivity, or robustness checks included when needed?
+- Are alternative explanations considered?
+
+### 6. Results and Interpretation
+
+- Are results clearly presented?
+- Do claims stay within the evidence?
+- Are figures, tables, and metrics understandable?
+- Are negative or null results handled honestly?
+
+### 7. Limitations and Threats to Validity
+
+- Are limitations specific rather than generic?
+- Are internal, external, construct, and conclusion-validity risks addressed?
+- Does the paper distinguish speculation from demonstrated results?
+
+### 8. Writing and Structure
+
+- Is the argument easy to follow?
+- Are sections organized around the research question?
+- Are definitions and notation clear?
+- Is the tone precise and scholarly?
+
+### 9. Citations
+
+- Do cited papers support the claims attached to them?
+- Are primary sources used where possible?
+- Are reviews labeled as reviews?
+- Are preprints labeled as preprints?
+- Are citation metadata and links correct?
+
+## Review Process
+
+1. Read the abstract, introduction, figures, and conclusion for claimed
+   contribution.
+2. Read methods and results for evidence quality.
+3. Check the strongest claims against cited sources.
+4. Score each applicable dimension.
+5. Separate critical blockers from revision suggestions.
+6. End with concrete next edits.
+
+## Output Template
+
+```markdown
+# Scholar Evaluation: <Artifact>
+
+## Overall Assessment
+
+- Overall score: <1-5 or N/A>
+- Confidence: <high | medium | low>
+- Summary: <3-5 sentences>
+
+## Dimension Scores
+
+| Dimension | Score | Evidence | Revision priority |
+| --- | ---: | --- | --- |
+| Problem and question |  |  |  |
+| Literature and context |  |  |  |
+| Methodology |  |  |  |
+| Data and evidence |  |  |  |
+| Analysis |  |  |  |
+| Results and interpretation |  |  |  |
+| Limitations |  |  |  |
+| Writing and structure |  |  |  |
+| Citations |  |  |  |
+
+## Critical Issues
+
+## Recommended Revisions
+
+## Evidence Checks Needed
+```
+
+## Pitfalls
+
+- Do not use the score as a substitute for concrete feedback.
+- Do not penalize a paper for omitting a dimension outside its scope.
+- Do not treat citation count, venue, or author reputation as proof of quality.
+- Do not accept unsupported claims just because they appear in the abstract.

package/assets/agent-skills/verification-loop/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: verification-loop
+description: "A comprehensive verification system for TITAN sessions."
+origin: ECC
+---
+
+# Verification Loop Skill
+
+A comprehensive verification system for TITAN sessions.
+
+## When to Use
+
+Invoke this skill:
+- After completing a feature or significant code change
+- Before creating a PR
+- When you want to ensure quality gates pass
+- After refactoring
+
+## Verification Phases
+
+### Phase 1: Build Verification
+```bash
+# Check if project builds
+npm run build 2>&1 | tail -20
+# OR
+pnpm build 2>&1 | tail -20
+```
+
+If build fails, STOP and fix before continuing.
+
+### Phase 2: Type Check
+```bash
+# TypeScript projects
+npx tsc --noEmit 2>&1 | head -30
+
+# Python projects
+pyright . 2>&1 | head -30
+```
+
+Report all type errors. Fix critical ones before continuing.
+
+### Phase 3: Lint Check
+```bash
+# JavaScript/TypeScript
+npm run lint 2>&1 | head -30
+
+# Python
+ruff check . 2>&1 | head -30
+```
+
+### Phase 4: Test Suite
+```bash
+# Run tests with coverage
+npm run test -- --coverage 2>&1 | tail -50
+
+# Check coverage threshold
+# Target: 80% minimum
+```
+
+Report:
+- Total tests: X
+- Passed: X
+- Failed: X
+- Coverage: X%
+
+### Phase 5: Security Scan
+```bash
+# Check for secrets
+grep -rn "sk-" --include="*.ts" --include="*.js" . 2>/dev/null | head -10
+grep -rn "api_key" --include="*.ts" --include="*.js" . 2>/dev/null | head -10
+
+# Check for console.log
+grep -rn "console.log" --include="*.ts" --include="*.tsx" src/ 2>/dev/null | head -10
+```
+
+### Phase 6: Diff Review
+```bash
+# Show what changed
+git diff --stat
+git diff HEAD~1 --name-only
+```
+
+Review each changed file for:
+- Unintended changes
+- Missing error handling
+- Potential edge cases
+
+## Output Format
+
+After running all phases, produce a verification report:
+
+```
+VERIFICATION REPORT
+==================
+
+Build:     [PASS/FAIL]
+Types:     [PASS/FAIL] (X errors)
+Lint:      [PASS/FAIL] (X warnings)
+Tests:     [PASS/FAIL] (X/Y passed, Z% coverage)
+Security:  [PASS/FAIL] (X issues)
+Diff:      [X files changed]
+
+Overall:   [READY/NOT READY] for PR
+
+Issues to Fix:
+1. ...
+2. ...
+```
+
+## Continuous Mode
+
+For long sessions, run verification every 15 minutes or after major changes:
+
+```markdown
+Set a mental checkpoint:
+- After completing each function
+- After finishing a component
+- Before moving to next task
+
+Run: /verify
+```
+
+## Integration with Hooks
+
+This skill complements PostToolUse hooks but provides deeper verification.
+Hooks catch issues immediately; this skill provides comprehensive review.

package/dist/agent/agent.js

@@ -35,6 +35,7 @@ import { getAgent } from "./multiAgent.js";
 import { isDangerous } from "../utils/safety.js";
 import { registerTool } from "./toolRunner.js";
 import { runAgentLoop } from "./agentLoop.js";
+import { detectSystemWidget, buildSystemWidgetGate } from "./systemWidgets.js";
 import { startTrace } from "./tracer.js";
 import { initSoulState, consolidateWisdom, clearSoulState, getWisdomHints } from "./soul.js";
 import logger from "../utils/logger.js";
@@ -489,12 +490,15 @@ ${memories.map((m) => `- ${m.key}: ${m.value}`).join("\n")}` : "";
   } catch {
   }
   let goalPlanBlock = "";
+  let goalSpecBlock = "";
   try {
     const { getSessionGoal } = await import("./autonomyContext.js");
     const goalCtx = sessionId ? getSessionGoal(sessionId) : null;
     if (goalCtx?.goalId) {
       const { renderGoalPlanForPrompt } = await import("./goalPlanFile.js");
       goalPlanBlock = renderGoalPlanForPrompt(goalCtx.goalId);
+      const { renderGoalSpecForPrompt } = await import("./goalSpec.js");
+      goalSpecBlock = renderGoalSpecForPrompt(goalCtx.goalId);
     }
   } catch {
   }
@@ -674,6 +678,10 @@ ${transientIncludes}` : "" },
     // Top-N most relevant lessons this agent has learned, injected
     // near the recency position so they actually inform the next move.
     { name: "agentLessons", content: agentLessonsBlock },
+    // v7.0 — Living goal SPEC (spec-driven workflow). The definition-of-done
+    // lands just before the plan so the agent checks acceptance criteria
+    // ("are we done?") before reciting the step ladder ("what's next?").
+    { name: "goalSpec", content: goalSpecBlock },
     // v6.0 Command Post upgrade #2 — Living goal plan (Manus recitation).
     // When the session is tied to a goal, the goal's plan.md surfaces
     // so the agent recites + updates progress every turn.
@@ -1148,34 +1156,19 @@ Continue executing this task NOW using the appropriate tools. Do NOT re-explain,
       taskEnforcementActive = true;
     }
     if (/\b(fix|change|modify|update|refactor|implement|add|remove|replace|uncomment|activate|enable|rewrite|patch|upgrade)\b.{0,80}\b(code|function|file|class|method|module|component|logic|bug|feature|session|title|tool|test)\b/i.test(message)) {
-      systemPrompt += "\n\nWhen editing code: 1) read the relevant files first, 2) make the actual changes using write_file or edit_file, 3) run tests to verify, 4) report what you changed. Do NOT stop after reading \u2014 actually save your changes.";
+      systemPrompt += "\n\nWhen editing code: 1) read the relevant file first with read_file, 2) make the change with edit_file (for a small change) or write_file \u2014 do NOT use shell/sed/echo/cat to edit files; edit_file is the correct, verifiable tool, 3) run tests to verify, 4) report what you changed. Do NOT stop after reading \u2014 actually save your changes.";
       taskEnforcementActive = true;
     }
-    const systemWidgetPatterns = [
-      { pattern: /\b(?:backups?|snapshots?|archives?)\b/i, widget: "system:backup", name: "Backup Manager" },
-      { pattern: /\b(?:training|train|specialists?|models?)\b/i, widget: "system:training", name: "Training Dashboard" },
-      { pattern: /\b(?:recipes?|playbooks?|workflows?|jarvis)\b/i, widget: "system:recipes", name: "Recipe Kitchen" },
-      { pattern: /\b(?:vram|gpu|nvidia)\b/i, widget: "system:vram", name: "VRAM Monitor" },
-      { pattern: /\b(?:teams?|members?|roles?|permissions?|rbac)\b/i, widget: "system:teams", name: "Team Hub" },
-      { pattern: /\b(?:cron|schedules?|jobs?|timers?)\b/i, widget: "system:cron", name: "Cron Scheduler" },
-      { pattern: /\b(?:checkpoints?|restores?|save state)\b/i, widget: "system:checkpoints", name: "Checkpoints" },
-      { pattern: /\b(?:organism|guardrails?)\b/i, widget: "system:organism", name: "Organism Monitor" },
-      { pattern: /\b(?:fleet|nodes?|routes?|mesh)\b/i, widget: "system:fleet", name: "Fleet Router" },
-      { pattern: /\b(?:captcha|form fill|web automation)\b/i, widget: "system:browser", name: "Browser Tools" },
-      // v6.0 step 1 — paperclip Bucket C / killed
-      { pattern: /\b(?:tests?|flaky|failing|coverage|eval)\b/i, widget: "system:eval", name: "Test Lab" }
-    ];
-    const imperativeRe = /\b(?:add|open|show|pin|create|launch|put|give\s+me|i\s+want|let'?s\s+see|i\s+need)\b/i;
-    const widgetNounRe = /\b(?:widget|panel|dashboard|hub|gallery|kitchen|scheduler)\b/i;
-    const hasWidgetIntent = imperativeRe.test(message) && widgetNounRe.test(message);
-    const matchedWidget = hasWidgetIntent ? systemWidgetPatterns.find((p) => p.pattern.test(message)) : null;
+    if (/\b(remind|schedule|every (day|week|morning|hour)|later|tomorrow|at \d|recurring|cron|alarm|automat)/i.test(message)) {
+      systemPrompt += "\n\nHONESTY RULE: never claim you scheduled, set a reminder, automated, sent, or posted something unless you ACTUALLY called the corresponding tool in this turn (the `reminder` tool for one-time reminders \u2014 action=set with message + ISO `when`; the `cron` tool for recurring jobs). If you cannot do it with your tools, say so plainly instead of pretending.";
+    }
+    const matchedWidget = detectSystemWidget(message);
     if (matchedWidget && !taskEnforcementActive) {
       systemPrompt += `
 
-The user is asking about ${matchedWidget.name}. You MUST call gallery_search for "${matchedWidget.widget}" FIRST to find the widget template, then call gallery_get to fetch it, and emit it through the _____widget gate as JSON with format "system":
+The user is asking about ${matchedWidget.name}. You MUST call gallery_search for "${matchedWidget.source}" FIRST to find the widget template, then call gallery_get to fetch it, and emit it through the _____widget gate as JSON with format "system":
 
-_____widget
-{ "name": "${matchedWidget.name}", "format": "system", "source": "${matchedWidget.widget}", "w": 6, "h": 6 }
+${buildSystemWidgetGate(matchedWidget)}
 
 Do NOT just describe it \u2014 actually create the widget on the canvas.`;
       taskEnforcementActive = true;
@@ -1479,7 +1472,7 @@ Synthesize these results into a coherent response for the user.`
   if (!budgetExhausted) {
     import("./checkpoint.js").then((m) => m.clearCheckpoints(session.id)).catch((e) => logger.debug("Agent", `Background op failed: ${e.message}`));
   }
-  if (toolsUsed.length > 0) {
+  if (toolsUsed.length > 0 && channel !== "eval") {
     const success = !finalContent.toLowerCase().includes("error") && !budgetExhausted;
     recordStrategy(message, [...new Set(toolsUsed)], orderedToolSequence.length, success, orderedToolSequence);
     if (orderedToolSequence.length > 0) {
@@ -1509,6 +1502,23 @@ Synthesize these results into a coherent response for the user.`
     logger.warn(COMPONENT, `[HallucinationGuard] Cloud model claimed action but toolsUsed is empty \u2014 sanitizing response`);
     finalContent = "I wasn't able to finish that task \u2014 the connection to my brain hiccupped. Try asking again, or I can switch to my offline mode if you prefer.";
   }
+  {
+    const sw = detectSystemWidget(message);
+    if (sw && !finalContent.includes("_____widget")) {
+      finalContent = finalContent ? `${finalContent}
+
+${buildSystemWidgetGate(sw)}` : buildSystemWidgetGate(sw);
+      logger.info(COMPONENT, `[SystemWidgetShortcut] Deterministically emitted _____widget gate for ${sw.source}`);
+    }
+  }
+  {
+    const claimsScheduled = /\b(i(?:'|’)?(?:ve| have)\s+(?:set|scheduled|created)|(?:reminder|schedule[d]?)\s+(?:is\s+)?(?:set|created|scheduled)|i(?:'|’)?ll remind you|scheduled a reminder)\b/i.test(finalContent);
+    const schedulingToolRan = toolsUsed.some((t) => /^(reminder|cron|schedule|event_trigger|workflows?|social_scheduler)/i.test(t));
+    if (claimsScheduled && !schedulingToolRan) {
+      finalContent += "\n\n\u26A0\uFE0F Correction: I described scheduling that, but I did not actually create a scheduled job this turn. Ask me again and I'll set it with the reminder tool properly.";
+      logger.warn(COMPONENT, "[HonestyGuard] Reply claimed scheduling without a scheduling tool \u2014 appended correction");
+    }
+  }
   addMessage(session, "assistant", finalContent, {
     model: modelUsed,
     tokenCount: totalCompletionTokens
@@ -1586,9 +1596,11 @@ Synthesize these results into a coherent response for the user.`
     durationMs,
     sessionId: session.id
   };
-  logTrajectory(trajectory);
-  processTrajectoryForSkills(trajectory);
-  processTrajectoryForLearningReview(trajectory);
+  if (channel !== "eval") {
+    logTrajectory(trajectory);
+    processTrajectoryForSkills(trajectory);
+  }
+  if (channel !== "eval") processTrajectoryForLearningReview(trajectory);
   trace.setModel(modelUsed);
   trace.setRounds(loopResult.toolCallDetails.length);
   trace.setTokens(totalPromptTokens, totalCompletionTokens);
@@ -1611,11 +1623,40 @@ Synthesize these results into a coherent response for the user.`
     });
   } catch {
   }
+  try {
+    const { recordSpan } = await import("../telemetry/traceStore.js");
+    let costUsd = 0;
+    try {
+      const { calculateActualCost } = await import("./costEstimator.js");
+      costUsd = calculateActualCost(modelUsed, { prompt: totalPromptTokens, completion: totalCompletionTokens });
+    } catch {
+    }
+    recordSpan({
+      sessionId: session.id,
+      startedAt: new Date(startTime).toISOString(),
+      durationMs,
+      model: modelUsed,
+      input: (message || "").slice(0, 500),
+      output: (finalContent || "").slice(0, 1e3),
+      toolsUsed: [...new Set(toolsUsed)],
+      promptTokens: totalPromptTokens,
+      completionTokens: totalCompletionTokens,
+      costUsd,
+      ok: !budgetExhausted && !!finalContent
+    });
+  } catch {
+  }
+  try {
+    const { maybeObserve } = await import("./observationWriter.js");
+    maybeObserve(channel, message || "", finalContent || "");
+  } catch {
+  }
   return {
     content: finalContent,
     sessionId: session.id,
     toolsUsed: [...new Set(toolsUsed)],
     attemptedTools: [...new Set(attemptedTools)],
+    orderedToolSequence: [...orderedToolSequence],
     tokenUsage: {
       prompt: totalPromptTokens,
       completion: totalCompletionTokens,