Source Summary

--- title: Strategist Logic description: What the AI strategist layer is trying to achieve and how to interpret its outputs status: evolving lastUpdated: "2026-02-13 07:22 ET (America/New_York)" owner: Product/Engineering --- # Strategist Logic This document explains the "strategist" layer in Dashboard Automator: the logic that turns messy project signals (G

Imported Context

title: Strategist Logic description: What the AI strategist layer is trying to achieve and how to interpret its outputs status: evolving lastUpdated: "2026-02-13 07:22 ET (America/New_York)" owner: Product/Engineering

Strategist Logic

This document explains the "strategist" layer in Dashboard Automator: the logic that turns messy project signals (GitHub activity + manual notes) into goals, health signals, risks, and recommendations for an owner-operator portfolio.

If you want the implementation/architecture map, see DOCS/how-it-works.md.

Problem This Project Solves

Portfolio status for a solo developer is usually scattered:

GitHub activity shows movement, but not intent, priorities, or whether work is "on track".
Manual notes exist, but they do not aggregate across projects and are hard to keep consistent.
Producing a portfolio-level update becomes a recurring tax: time spent collecting signals instead of shipping.

Dashboard Automator aims to reduce that tax by continuously ingesting activity, synthesizing likely goals, and publishing a snapshot you can use as a command center and export artifact.

High-Level Goals (Strategist Outcomes)

The strategist is optimized for a single authenticated owner-operator workflow (current MVP reality). Its outcomes are:

Convert activity into intent: infer 2-4 plausible goals per repository (not a full roadmap).
Create portfolio-level focus visibility: summarize overall focus/health and surface cross-repo risks.
Make health legible at a glance: compute KPIs and per-project health labels for fast scanning.
Support auditing and iteration: persist agent runs and allow explicit user evaluations of AI outputs.
Generate a stable artifact: create a JSON snapshot suitable for export and downstream workflows.

Inputs (What The Strategist Uses)

The strategist primarily works from:

GitHub ingested events per included repo (commits, PRs, issues, releases).
Manual logs you add inside the app (notes/tasks/conversations), optionally attached to a repo.
Repo metadata (language, stars, open issues, description).

Outputs (What The Strategist Produces)

Repository goals

For each included repository, the strategist synthesizes 2-4 goals with:

title
description
status: active | completed | at_risk | stalled
confidence: 0.0-1.0 (model-provided)
evidence: short textual citation of the activity/notes that motivated the goal

Portfolio analysis

For the whole included portfolio:

focusScore: 0.0-1.0 (model-provided)
risks: { repo, risk, severity } with severity high | medium | low
recommendations: 3-5 actionable next-step suggestions
summary: 2-3 sentence health narrative

Snapshot (portfolio artifact)

The strategist emits a single JSON snapshot containing:

KPIs (repo count, activity totals, goal totals, open-issue totals, etc.)
portfolio analysis (above)
per-project summaries including a computed healthScore and healthLabel
a 30-day activity timeline
a "recent activities" feed

Strategist Mechanics (Current Logic)

The strategist loop (conceptual)

Ingest: fetch recent GitHub activity into the database.
Synthesize: generate repo goals from the latest activity + manual logs.
Analyze: generate portfolio-level focus, risks, and recommendations.
Snapshot: assemble a portfolio snapshot (KPIs + health + timeline) and store/export it.

Time windows and truncation

Current implementation intentionally bounds input size:

Goal synthesis uses up to 30 most recent activities per repo.
Portfolio snapshot uses a rolling 30-day activity window and keeps a top 50 "recent activities" list.

Scoring and labels (non-AI)

Some outputs are deterministic heuristics (not model-generated):

activityScore = min(1, recentRepoActivities / 20)
goalScore = average(goal.confidence) for the repo (fallback 0.3 when there are no goals)
healthScore = activityScore * 0.5 + goalScore * 0.3 + (openIssues > 0 ? 0.2 : 0)
healthLabel derived from healthScore:
- >= 0.7 => healthy
- >= 0.4 => warning
- else => critical

Note: the current openIssues term increases score when open issues exist. If you intend open issues to reduce health, this term should be inverted in a future checkpoint.

Trust Model (Confidence, Gating, and Review)

The strategist stores a numeric confidence per goal (model-provided) and exposes it in the UI.

Product docs define a stricter UX target (only show outputs >= 0.85 in primary views, with lower-confidence content accessible in a closed drawer), but that gating behavior is not currently implemented in the UI. Today, the system records and displays confidence rather than suppressing low-confidence outputs.

The system does support:

Agent run logging (inputs, outputs, latency, token usage).
Human evaluation of runs (rating + verdict + feedback) to drive iteration.

Constraints and Non-Goals (Strategist Scope)

Constraints:

JSON-only snapshot export.
Single-user, session-authenticated usage (current MVP scope).
No external "source of truth" beyond GitHub + manual logs in the app database.

Non-goals (currently):

Fully automated project management or deterministic roadmaps.
Multi-tenant team workflows and role-based access control.

Provenance

Source file: Dashboard-Automator/DOCS/strategist-logic.md
Source URL: https://github.com/maggielerman/Dashboard-Automator/blob/main/DOCS/strategist-logic.md