@mndrk/agx 2.0.56 → 2.1.0

package/cloud-runtime/standalone/apps/local/lib/objective-health-history.ts

@@ -0,0 +1,198 @@
+import type { ObjectiveActivityFile } from "@/src/objectives/activities/types";
+import type { ProjectObjectiveHealth } from "@/lib/project-objectives";
+
+export const PROJECT_OBJECTIVE_HEALTH_HISTORY_METADATA_KEY = "project_objective_health_history";
+
+const OBJECTIVE_HEALTH_LINE_PATTERN =
+  /(?:^|\n)Objective health:\s*(\d{1,3})%\s*(On track|At risk|Off track|Done)\b/im;
+const MAX_OBJECTIVE_HEALTH_SAMPLES = 200;
+
+const STATUS_FROM_LABEL: Record<string, ProjectObjectiveHealth> = {
+  "on track": "on_track",
+  "at risk": "at_risk",
+  "off track": "off_track",
+  done: "done",
+};
+
+export interface ObjectiveHealthSample {
+  progress: number;
+  status: ProjectObjectiveHealth;
+  recordedAt: string;
+  source?: string;
+  note?: string;
+  objectiveId?: string | null;
+  objectiveKey?: string | null;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function normalizeProgress(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(100, Math.round(value)));
+}
+
+function normalizeStatus(value: unknown): ProjectObjectiveHealth | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "on_track" || normalized === "at_risk" || normalized === "off_track" || normalized === "done") {
+    return normalized as ProjectObjectiveHealth;
+  }
+  return STATUS_FROM_LABEL[normalized] ?? null;
+}
+
+function normalizeTimestamp(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) return null;
+  return new Date(parsed).toISOString();
+}
+
+function normalizeOptionalString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function normalizeObjectiveHealthSample(value: unknown): ObjectiveHealthSample | null {
+  if (!isRecord(value)) return null;
+
+  const status = normalizeStatus(value.status);
+  const recordedAt = normalizeTimestamp(value.recordedAt);
+  if (!status || !recordedAt) {
+    return null;
+  }
+
+  return {
+    progress: normalizeProgress(value.progress),
+    status,
+    recordedAt,
+    source: normalizeOptionalString(value.source),
+    note: normalizeOptionalString(value.note),
+    objectiveId: normalizeOptionalString(value.objectiveId) ?? null,
+    objectiveKey: normalizeOptionalString(value.objectiveKey) ?? null,
+  };
+}
+
+function sortSamplesByRecordedAt(samples: ObjectiveHealthSample[]): ObjectiveHealthSample[] {
+  return [...samples].sort(
+    (left, right) => Date.parse(left.recordedAt) - Date.parse(right.recordedAt),
+  );
+}
+
+export function mergeObjectiveHealthSamples(
+  ...collections: Array<ObjectiveHealthSample[] | null | undefined>
+): ObjectiveHealthSample[] {
+  const flattened = collections.flatMap((collection) => collection ?? []);
+  const deduped: ObjectiveHealthSample[] = [];
+
+  for (const sample of sortSamplesByRecordedAt(flattened)) {
+    const previous = deduped[deduped.length - 1] ?? null;
+    if (
+      previous &&
+      previous.progress === sample.progress &&
+      previous.status === sample.status &&
+      (
+        !previous.source ||
+        !sample.source ||
+        previous.source === sample.source
+      ) &&
+      Math.abs(Date.parse(sample.recordedAt) - Date.parse(previous.recordedAt)) <= 5_000
+    ) {
+      continue;
+    }
+    deduped.push(sample);
+  }
+
+  return deduped;
+}
+
+export function readObjectiveHealthHistory(
+  metadata: Record<string, unknown> | undefined,
+  objectiveId: string,
+): ObjectiveHealthSample[] {
+  if (!isRecord(metadata) || !objectiveId.trim()) return [];
+
+  const rawHistory = metadata[PROJECT_OBJECTIVE_HEALTH_HISTORY_METADATA_KEY];
+  if (!isRecord(rawHistory)) return [];
+
+  const entries = rawHistory[objectiveId.trim()];
+  if (!Array.isArray(entries)) return [];
+
+  return mergeObjectiveHealthSamples(
+    entries
+      .map((entry) => normalizeObjectiveHealthSample(entry))
+      .filter((entry): entry is ObjectiveHealthSample => Boolean(entry)),
+  );
+}
+
+export function appendObjectiveHealthSample(
+  metadata: Record<string, unknown>,
+  sample: ObjectiveHealthSample & { objectiveId: string },
+): Record<string, unknown> {
+  const objectiveId = sample.objectiveId.trim();
+  if (!objectiveId) {
+    return metadata;
+  }
+
+  const existingHistory = readObjectiveHealthHistory(metadata, objectiveId);
+  const mergedHistory = mergeObjectiveHealthSamples(existingHistory, [sample]).slice(
+    -MAX_OBJECTIVE_HEALTH_SAMPLES,
+  );
+
+  const rawHistory = isRecord(metadata[PROJECT_OBJECTIVE_HEALTH_HISTORY_METADATA_KEY])
+    ? (metadata[PROJECT_OBJECTIVE_HEALTH_HISTORY_METADATA_KEY] as Record<string, unknown>)
+    : {};
+
+  return {
+    ...metadata,
+    [PROJECT_OBJECTIVE_HEALTH_HISTORY_METADATA_KEY]: {
+      ...rawHistory,
+      [objectiveId]: mergedHistory.map((entry) => ({
+        progress: normalizeProgress(entry.progress),
+        status: entry.status,
+        recordedAt: entry.recordedAt,
+        ...(entry.source ? { source: entry.source } : {}),
+        ...(entry.note ? { note: entry.note } : {}),
+        ...(entry.objectiveId ? { objectiveId: entry.objectiveId } : {}),
+        ...(entry.objectiveKey ? { objectiveKey: entry.objectiveKey } : {}),
+      })),
+    },
+  };
+}
+
+export function parseObjectiveHealthSampleFromActivity(
+  activity: ObjectiveActivityFile,
+): ObjectiveHealthSample | null {
+  if (activity.type !== "status-update") return null;
+
+  const match = activity.body.match(OBJECTIVE_HEALTH_LINE_PATTERN);
+  if (!match) return null;
+
+  const progress = normalizeProgress(Number(match[1]));
+  const status = normalizeStatus(match[2]);
+  const recordedAt = normalizeTimestamp(activity.createdAt);
+  if (!status || !recordedAt) return null;
+
+  return {
+    progress,
+    status,
+    recordedAt,
+    source: normalizeOptionalString(activity.source),
+    objectiveKey: normalizeOptionalString(activity.objectiveLabel) ?? null,
+  };
+}
+
+export function buildObjectiveHealthHistoryFromActivities(
+  activities: ObjectiveActivityFile[],
+  objectiveKey?: string | null,
+): ObjectiveHealthSample[] {
+  return mergeObjectiveHealthSamples(
+    activities
+      .map((activity) => parseObjectiveHealthSampleFromActivity(activity))
+      .filter((sample): sample is ObjectiveHealthSample => {
+        if (!sample) return false;
+        if (!objectiveKey) return true;
+        return sample.objectiveKey === objectiveKey;
+      }),
+  );
+}

package/cloud-runtime/standalone/apps/local/lib/project-objective-context.ts

@@ -87,3 +87,13 @@ export async function persistProjectHealthSnapshot(input: {
     metadata: writeProjectHealthSnapshot(input.currentMetadata ?? {}, input.snapshot),
   });
 }
+
+export async function persistProjectObjectiveMetadata(input: {
+  projectId: string;
+  currentMetadata: Record<string, unknown> | undefined;
+  transformMetadata: (metadata: Record<string, unknown>) => Record<string, unknown>;
+}) {
+  return db.updateProject(input.projectId, LOCAL_USER.id, {
+    metadata: input.transformMetadata(input.currentMetadata ?? {}),
+  });
+}

package/cloud-runtime/standalone/apps/local/lib/project-objectives.ts

@@ -20,8 +20,6 @@ export interface ProjectObjective {
   /** @deprecated Use notes instead. Derived from the first note for backward compat. */
   summary: string;
   notes?: ObjectiveNoteFile[];
-  cadence: string;
-  condition: string;
   progress: number;
   status: ProjectObjectiveHealth;
   createdAt: string;
@@ -77,8 +75,6 @@ interface CreateProjectObjectiveInput {
   chatSessionVersion?: number;
   scheduledTaskIds?: string[];
   summary?: string;
-  cadence?: string;
-  condition?: string;
   progress?: number;
   status?: ProjectObjectiveHealth;
   now: string;
@@ -270,8 +266,6 @@ function normalizeObjective(raw: unknown): ProjectObjective | null {
     chatSessionVersion: readNonNegativeInteger(raw.chatSessionVersion, 0),
     scheduledTaskIds: readStringArray(raw.scheduledTaskIds ?? raw.promptJobIds),
     summary: readString(raw.summary),
-    cadence: readString(raw.cadence),
-    condition: readString(raw.condition),
     progress: readProgress(raw.progress),
     status: readObjectiveHealth(raw.status),
     createdAt,
@@ -370,7 +364,6 @@ function normalizeLegacyGoal(raw: unknown): ProjectObjective | null {
   return normalizeObjective({
     ...raw,
     summary: mergedSummary,
-    cadence: "",
   });
 }
 
@@ -503,8 +496,6 @@ export function createProjectObjective(
     ),
     scheduledTaskIds: readStringArray(input.scheduledTaskIds ?? []),
     summary: input.summary?.trim() ?? "",
-    cadence: input.cadence?.trim() ?? "",
-    condition: input.condition?.trim() ?? "",
     progress: readProgress(input.progress ?? 0),
     status: input.status ?? "on_track",
     createdAt: input.now,

package/cloud-runtime/standalone/apps/local/skills-lock.json

@@ -0,0 +1,20 @@
+{
+  "version": 1,
+  "skills": {
+    "dispatching-parallel-agents": {
+      "source": "obra/superpowers",
+      "sourceType": "github",
+      "computedHash": "e21044ae7496fc285f1df9ff3fb518a3a20bea6f5216c1f59f4987e12c769a0a"
+    },
+    "requesting-code-review": {
+      "source": "obra/superpowers",
+      "sourceType": "github",
+      "computedHash": "246e65cd72a7e360987d94e6c61564ce6d71c6361d1784d529d70e4cbbe8522d"
+    },
+    "verification-before-completion": {
+      "source": "obra/superpowers",
+      "sourceType": "github",
+      "computedHash": "9b446f0c7fe1cfb560b1d34439523b1a76d5f177290007b2c053a1c749a4a8ba"
+    }
+  }
+}

package/cloud-runtime/standalone/apps/local/src/automations/adapters.ts

@@ -56,6 +56,9 @@ export function automationRecordToPromptJob(record: AutomationRecord): PromptJob
     catchUpPolicy: execution.catchUpPolicy,
     cancelCheckSec: execution.cancelCheckSec,
     executionMode: record.definition.target.executionMode ?? DEFAULT_PROMPT_JOB_EXECUTION_MODE,
+    scriptPrompt: record.definition.target.scriptPrompt ?? "",
+    teamId: record.definition.target.teamId ?? "",
+    builtIn: record.definition.target.builtIn === true || record.definition.target.executionMode === "objective_worker" || record.definition.target.executionMode === "linear_worker",
     condition: execution.condition ?? (trigger.type === "condition" ? trigger.condition : ""),
     nextRunAt: record.runtimeState.nextRunAt ?? null,
     lastRunAt: record.runtimeState.lastRunAt ?? null,
@@ -93,6 +96,8 @@ export function promptJobToAutomationDefinition(job: LegacyPromptJobLike): Autom
       ...(job.executionMode !== DEFAULT_PROMPT_JOB_EXECUTION_MODE
         ? { executionMode: job.executionMode }
         : {}),
+      ...(job.scriptPrompt ? { scriptPrompt: job.scriptPrompt } : {}),
+      ...(job.teamId ? { teamId: job.teamId } : {}),
     },
     createdAt: job.createdAt,
     body: job.prompt,

package/cloud-runtime/standalone/apps/local/src/automations/types.ts

@@ -38,11 +38,16 @@ export interface AutomationExecution {
 
 export interface PromptJobAutomationTarget {
   type: "prompt_job";
+  builtIn?: boolean;
   agentId?: string;
   provider?: string;
   model?: string;
   cliArgs?: string;
   prompt?: string;
+  /** For linear_worker: the prompt injected into the agent chat session when working a ticket. */
+  scriptPrompt?: string;
+  /** For linear_worker: the team whose agents participate in the linear chat session. */
+  teamId?: string;
   objectiveId?: string;
   objectiveKey?: string;
   executionMode?: PromptJobExecutionMode;

package/cloud-runtime/standalone/apps/local/src/automations/validation.ts

@@ -212,20 +212,25 @@ function normalizePromptTarget(value: unknown): PromptJobAutomationTarget {
   const prompt = typeof raw.prompt === "string" && raw.prompt.length > 0
     ? raw.prompt
     : undefined;
+  const scriptPrompt = typeof raw.scriptPrompt === "string" && raw.scriptPrompt.length > 0
+    ? raw.scriptPrompt
+    : undefined;
+  const teamId = asTrimmedString(raw.teamId);
   const objectiveId = asTrimmedString(raw.objectiveId);
   const objectiveKey = asTrimmedString(raw.objectiveKey);
   const executionMode = asTrimmedString(raw.executionMode);
 
-  if (!provider && !agentId) {
-    throw new Error("Prompt-job target requires provider or agentId.");
+  if (!provider && !agentId && !teamId) {
+    throw new Error("Prompt-job target requires provider, agentId, or teamId.");
   }
   if (
     executionMode &&
     executionMode !== "prompt" &&
-    executionMode !== "objective_linear_ticket"
+    executionMode !== "objective_worker" &&
+    executionMode !== "linear_worker"
   ) {
     throw new Error(
-      'Prompt-job target.executionMode must be "prompt" or "objective_linear_ticket".',
+      'Prompt-job target.executionMode must be "prompt", "objective_worker", or "linear_worker".',
     );
   }
 
@@ -234,9 +239,11 @@ function normalizePromptTarget(value: unknown): PromptJobAutomationTarget {
   if (model) target.model = model;
   if (cliArgs !== undefined) target.cliArgs = cliArgs;
   if (prompt !== undefined) target.prompt = prompt;
+  if (scriptPrompt !== undefined) target.scriptPrompt = scriptPrompt;
+  if (teamId) target.teamId = teamId;
   if (objectiveId) target.objectiveId = objectiveId;
   if (objectiveKey) target.objectiveKey = objectiveKey;
-  if (executionMode === "prompt" || executionMode === "objective_linear_ticket") {
+  if (executionMode === "prompt" || executionMode === "objective_worker" || executionMode === "linear_worker") {
     target.executionMode = executionMode;
   }
   return target;

package/cloud-runtime/standalone/apps/local/src/objectives/parser.ts

@@ -64,8 +64,6 @@ export function parseObjectiveFrontmatter(raw: Record<string, unknown>, summary:
     chatSessionVersion: readNonNegativeInteger(raw.chatSessionVersion, 0),
     scheduledTaskIds: readStringArray(raw.scheduledTaskIds),
     summary,
-    cadence: readString(raw.cadence),
-    condition: readString(raw.condition),
     progress: readProgress(raw.progress),
     status: readHealth(raw.status),
     createdAt,

package/cloud-runtime/standalone/apps/local/src/objectives/serializer.ts

@@ -25,8 +25,6 @@ function serializeObjectiveFrontmatter(objective: ProjectObjective): string {
     key: objective.key,
     status: objective.status,
     progress: objective.progress || undefined,
-    cadence: objective.cadence,
-    condition: objective.condition,
     threadId: objective.threadId,
     chatSessionVersion: objective.chatSessionVersion || undefined,
     scheduledTaskIds: objective.scheduledTaskIds.length > 0 ? objective.scheduledTaskIds : undefined,

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/linear-worker-constants.ts

@@ -0,0 +1,38 @@
+export const LINEAR_WORKER_JOB_NAME = 'Linear worker';
+export const LINEAR_WORKER_DEFAULT_CADENCE = 'every 30 minutes';
+
+/**
+ * Default selection prompt — guides the controller LLM when picking which ticket to work on.
+ */
+export const LINEAR_WORKER_DEFAULT_PROMPT = `Pick the highest-priority actionable ticket. Prefer tickets that:
+1. Are already started (existing branches, PRs, or prior comments) — continue where you left off.
+2. Are assigned to you or unassigned.
+3. Have the most urgent priority or earliest due date.
+
+Skip tickets with the \`active-session\` label — another agent is already working on them.`;
+
+/**
+ * Default execution prompt — injected into the agent chat session when working a selected ticket.
+ * When empty, the system falls back to the built-in linear execution prompt (buildLinearExecutionPrompt).
+ * Supports template variables: {{ticket.identifier}}, {{ticket.title}}, {{ticket.status}},
+ * {{ticket.assignee}}, {{project.name}}, {{project.slug}}, {{knowledge_base.root}},
+ * {{knowledge_base.issue_path}}, {{worktree.path}}.
+ */
+export const LINEAR_WORKER_DEFAULT_SCRIPT_PROMPT = `Work on {{ticket.identifier}}: {{ticket.title}}
+
+## Workflow
+
+1. **Read the ticket** — Read the full issue and comment thread via Linear MCP before acting.
+2. **Resume existing work** — Check for existing branches, PRs, knowledge-base notes, or prior discussion. Continue where things left off.
+3. **If unclear** — Post a clarifying comment on the ticket and stop. Don't guess.
+4. **If fresh** — Investigate the codebase, draft a plan, post it as a comment. Stop and wait for approval.
+5. **If plan is approved** — Create a git worktree, implement the fix, run tests, commit, push, and create a PR linking the ticket.
+6. **If PR exists** — Check CI, address review feedback, or confirm merge. Don't start over.
+
+## Rules
+
+- Work in an isolated git worktree — never modify the main checkout directly.
+- Keep Linear accurate: update status, post comments, link PRs.
+- Add the \`active-session\` label when starting. Remove it when done.
+- Leave everything in a resumable state. Clean up worktrees when finished.
+- One ticket per session.`;

package/cloud-runtime/standalone/apps/local/src/prompt-scheduler/linear-worker-job.ts

@@ -0,0 +1,47 @@
+import { getPromptJobStore } from './get-store';
+import type { PromptJob } from './types';
+export {
+  LINEAR_WORKER_JOB_NAME,
+  LINEAR_WORKER_DEFAULT_CADENCE,
+  LINEAR_WORKER_DEFAULT_PROMPT,
+} from './linear-worker-constants';
+import {
+  LINEAR_WORKER_JOB_NAME,
+  LINEAR_WORKER_DEFAULT_CADENCE,
+  LINEAR_WORKER_DEFAULT_PROMPT,
+} from './linear-worker-constants';
+
+export function findLinearWorkerJob(
+  projectId?: string,
+): PromptJob | null {
+  const store = getPromptJobStore();
+  const jobs = store.listJobs(projectId ? { projectId } : undefined);
+  return jobs.find((job) => job.executionMode === 'linear_worker') ?? null;
+}
+
+export function ensureLinearWorkerJob(input: {
+  projectId?: string;
+  prompt?: string;
+  cadence?: string;
+  agentId?: string;
+  provider?: string;
+  model?: string;
+}): PromptJob {
+  const existing = findLinearWorkerJob(input.projectId);
+  if (existing) {
+    return existing;
+  }
+
+  const store = getPromptJobStore();
+  return store.createJob({
+    name: LINEAR_WORKER_JOB_NAME,
+    prompt: input.prompt || LINEAR_WORKER_DEFAULT_PROMPT,
+    executionMode: 'linear_worker',
+    projectId: input.projectId,
+    builtIn: true,
+    cadence: input.cadence || LINEAR_WORKER_DEFAULT_CADENCE,
+    provider: input.provider ?? 'claude',
+    model: input.model,
+    agentId: input.agentId,
+  });
+}