stagent 0.9.6 → 0.11.0

package/src/lib/db/schema.ts

@@ -29,6 +29,12 @@ export const tasks = sqliteTable(
       .notNull(),
     assignedAgent: text("assigned_agent"),
     agentProfile: text("agent_profile"),
+    /** Runtime actually used for the most recent execution attempt. */
+    effectiveRuntimeId: text("effective_runtime_id"),
+    /** Model actually used for the most recent execution attempt. */
+    effectiveModelId: text("effective_model_id"),
+    /** Human-readable reason when execution fell back from the requested runtime/model. */
+    runtimeFallbackReason: text("runtime_fallback_reason"),
     priority: integer("priority").default(2).notNull(),
     result: text("result"),
     sessionId: text("session_id"),
@@ -40,6 +46,21 @@ export const tasks = sqliteTable(
     workflowRunNumber: integer("workflow_run_number"),
     /** Resolved per-task budget cap in USD — set by workflow engine for child tasks */
     maxBudgetUsd: real("max_budget_usd"),
+    /** When the slot for this task was atomically claimed */
+    slotClaimedAt: integer("slot_claimed_at", { mode: "timestamp" }),
+    /** Wall-clock expiry; reaper aborts tasks whose lease has passed */
+    leaseExpiresAt: integer("lease_expires_at", { mode: "timestamp" }),
+    /**
+     * Explicit terminal-state reason written by the runtime adapter at
+     * failure/abort transitions (e.g. 'turn_limit_exceeded', 'lease_expired',
+     * 'aborted', 'sdk_error'). Distinct from `result` — `result` holds the
+     * agent's final output text, while `failureReason` holds a machine-readable
+     * classifier that drives scheduler failure-streak logic without re-parsing
+     * error prose.
+     */
+    failureReason: text("failure_reason"),
+    /** Per-task turn budget copied from schedules.maxTurns at firing time */
+    maxTurns: integer("max_turns"),
     createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
     updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
   },
@@ -49,6 +70,7 @@ export const tasks = sqliteTable(
     index("idx_tasks_workflow_id").on(table.workflowId),
     index("idx_tasks_schedule_id").on(table.scheduleId),
     index("idx_tasks_agent_profile").on(table.agentProfile),
+    index("idx_tasks_running_scheduled").on(table.status, table.sourceType, table.leaseExpiresAt),
   ]
 );
 
@@ -65,6 +87,13 @@ export const workflows = sqliteTable("workflows", {
   runNumber: integer("run_number").default(0).notNull(),
   /** Runtime to use for all steps (nullable — falls back to system default) */
   runtimeId: text("runtime_id"),
+  /**
+   * Epoch millisecond timestamp at which a paused (delayed) workflow is due to resume.
+   * Null for workflows that are not waiting on a delay step. Indexed via
+   * idx_workflows_resume_at (partial index on non-null values) so the scheduler tick
+   * can efficiently find due workflows. See features/workflow-step-delays.md.
+   */
+  resumeAt: integer("resume_at"),
   createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
   updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
 });
@@ -210,6 +239,20 @@ export const schedules = sqliteTable(
     failureStreak: integer("failure_streak").default(0).notNull(),
     /** Detected reason for the most recent failure (turn_limit_exceeded, timeout, etc.) */
     lastFailureReason: text("last_failure_reason"),
+    /** Hard cap on turns per firing; NULL inherits the global MAX_TURNS setting */
+    maxTurns: integer("max_turns"),
+    /** Timestamp when maxTurns was last edited — drives first-breach grace */
+    maxTurnsSetAt: integer("max_turns_set_at", { mode: "timestamp" }),
+    /** Wall-clock lease override in seconds; NULL inherits global default (1200s) */
+    maxRunDurationSec: integer("max_run_duration_sec"),
+    /**
+     * Counter separate from failureStreak — increments only on maxTurns breach.
+     * Reset to 0 on any non-breach outcome (successful run, generic failure, or
+     * first-breach grace window after maxTurnsSetAt). Auto-pause at 5. This
+     * higher threshold + grace window protects users from tripping auto-pause
+     * via a misconfigured maxTurns edit.
+     */
+    turnBudgetBreachStreak: integer("turn_budget_breach_streak").default(0).notNull(),
     createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
     updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
   },
@@ -307,6 +350,7 @@ export const usageLedger = sqliteTable(
         "context_summarization",
         "chat_turn",
         "profile_assist",
+        "manual_force_bypass",
       ],
     }).notNull(),
     runtimeId: text("runtime_id").notNull(),
@@ -504,6 +548,26 @@ export const conversations = sqliteTable(
       .notNull(),
     sessionId: text("session_id"),
     contextScope: text("context_scope"), // JSON: context config overrides
+    /**
+     * Opaque skill ID of the Stagent-activated skill for this conversation.
+     * When set, the context builder injects that skill's SKILL.md into the
+     * Tier 0 system prompt every turn. Primary use case is Ollama (no
+     * SDK-native skill support); Claude and Codex can also use it as a
+     * programmatic skill-activation path alongside their native Skill tools.
+     *
+     * See `features/chat-ollama-native-skills.md`.
+     */
+    activeSkillId: text("active_skill_id"),
+    /**
+     * Composition v1 — array of additionally-activated skill IDs (beyond
+     * the legacy `activeSkillId`). Default `[]`. Read paths merge legacy
+     * + new and dedupe via `mergeActiveSkillIds`. Stored as JSON text.
+     *
+     * See `features/chat-skill-composition.md`.
+     */
+    activeSkillIds: text("active_skill_ids", { mode: "json" })
+      .$type<string[]>()
+      .default([] as unknown as string[]),
     createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
     updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
   },
@@ -1162,29 +1226,6 @@ export const snapshots = sqliteTable(
 
 export type SnapshotRow = InferSelectModel<typeof snapshots>;
 
-// ── License ──────────────────────────────────────────────────────────
-
-export const license = sqliteTable("license", {
-  id: text("id").primaryKey(),
-  supabaseUserId: text("supabase_user_id"),
-  tier: text("tier", { enum: ["community", "solo", "operator", "scale"] })
-    .default("community")
-    .notNull(),
-  status: text("status", { enum: ["active", "inactive", "grace"] })
-    .default("inactive")
-    .notNull(),
-  email: text("email"),
-  activatedAt: integer("activated_at", { mode: "timestamp" }),
-  expiresAt: integer("expires_at", { mode: "timestamp" }),
-  lastValidatedAt: integer("last_validated_at", { mode: "timestamp" }),
-  gracePeriodExpiresAt: integer("grace_period_expires_at", { mode: "timestamp" }),
-  encryptedToken: text("encrypted_token"),
-  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
-  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
-});
-
-export type LicenseRow = InferSelectModel<typeof license>;
-
 // ── Workflow Execution Stats ─────────────────────────────────────────
 
 export const workflowExecutionStats = sqliteTable("workflow_execution_stats", {
@@ -1212,3 +1253,33 @@ export const workflowExecutionStats = sqliteTable("workflow_execution_stats", {
 });
 
 export type WorkflowExecutionStatsRow = InferSelectModel<typeof workflowExecutionStats>;
+
+// ── Schedule Firing Metrics ───────────────────────────────────────────
+
+export const scheduleFiringMetrics = sqliteTable(
+  "schedule_firing_metrics",
+  {
+    id: text("id").primaryKey(),
+    scheduleId: text("schedule_id")
+      .references(() => schedules.id)
+      .notNull(),
+    taskId: text("task_id").references(() => tasks.id),
+    firedAt: integer("fired_at", { mode: "timestamp" }).notNull(),
+    slotClaimedAt: integer("slot_claimed_at", { mode: "timestamp" }),
+    completedAt: integer("completed_at", { mode: "timestamp" }),
+    slotWaitMs: integer("slot_wait_ms"),
+    durationMs: integer("duration_ms"),
+    turnCount: integer("turn_count"),
+    maxTurnsAtFiring: integer("max_turns_at_firing"),
+    eventLoopLagMs: real("event_loop_lag_ms"),
+    peakRssMb: integer("peak_rss_mb"),
+    chatStreamsActive: integer("chat_streams_active"),
+    concurrentSchedules: integer("concurrent_schedules"),
+    failureReason: text("failure_reason"),
+  },
+  (table) => [
+    index("idx_sfm_schedule_time").on(table.scheduleId, table.firedAt),
+  ]
+);
+
+export type ScheduleFiringMetricRow = InferSelectModel<typeof scheduleFiringMetrics>;

package/src/lib/environment/__tests__/auto-promote.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+vi.mock("@/lib/settings/helpers", () => ({
+  getSettingSync: vi.fn(),
+}));
+
+vi.mock("../profile-linker", () => ({
+  linkArtifactsToProfiles: vi.fn(),
+}));
+
+// The module under test depends on suggestProfilesTiered + createProfileFromSuggestion,
+// which live in the same file. We test via the real function but stub its
+// collaborators (getArtifacts + listProfiles) through their imported modules.
+vi.mock("../data", () => ({
+  getArtifacts: vi.fn(() => []),
+}));
+
+vi.mock("@/lib/agents/profiles/registry", () => ({
+  listProfiles: vi.fn(() => []),
+  createProfile: vi.fn(),
+}));
+
+import { autoPromoteUnlinkedSkills } from "../profile-generator";
+import { getSettingSync } from "@/lib/settings/helpers";
+import { linkArtifactsToProfiles } from "../profile-linker";
+import { getArtifacts } from "../data";
+import { createProfile } from "@/lib/agents/profiles/registry";
+
+const mockGetSettingSync = getSettingSync as ReturnType<typeof vi.fn>;
+const mockLinker = linkArtifactsToProfiles as ReturnType<typeof vi.fn>;
+const mockGetArtifacts = getArtifacts as ReturnType<typeof vi.fn>;
+const mockCreateProfile = createProfile as ReturnType<typeof vi.fn>;
+
+function unlinkedSkill(name: string) {
+  return {
+    id: `art-${name}`,
+    scanId: "scan-1",
+    tool: "claude-code",
+    category: "skill",
+    scope: "user",
+    name,
+    relPath: `${name}/SKILL.md`,
+    absPath: `/home/u/.claude/skills/${name}/SKILL.md`,
+    contentHash: "abc",
+    preview: `---\nname: ${name}\ndescription: A ${name} skill\n---\n`,
+    metadata: null,
+    sizeBytes: 100,
+    modifiedAt: new Date(),
+    createdAt: new Date(),
+    linkedProfileId: null,
+  };
+}
+
+describe("autoPromoteUnlinkedSkills", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns empty result when setting is disabled", () => {
+    mockGetSettingSync.mockReturnValue("false");
+    mockGetArtifacts.mockReturnValue([unlinkedSkill("alpha")]);
+
+    const result = autoPromoteUnlinkedSkills("scan-1");
+
+    expect(result.created).toEqual([]);
+    expect(mockCreateProfile).not.toHaveBeenCalled();
+    expect(mockLinker).not.toHaveBeenCalled();
+  });
+
+  it("returns empty result when setting is missing (default off)", () => {
+    mockGetSettingSync.mockReturnValue(null);
+    mockGetArtifacts.mockReturnValue([unlinkedSkill("alpha")]);
+
+    const result = autoPromoteUnlinkedSkills("scan-1");
+
+    expect(result.created).toEqual([]);
+    expect(mockCreateProfile).not.toHaveBeenCalled();
+  });
+
+  it("creates profiles for every Tier 2 suggestion and re-links when enabled", () => {
+    mockGetSettingSync.mockReturnValue("true");
+    mockGetArtifacts.mockReturnValue([
+      unlinkedSkill("alpha"),
+      unlinkedSkill("beta"),
+    ]);
+
+    const result = autoPromoteUnlinkedSkills("scan-1");
+
+    expect(mockCreateProfile).toHaveBeenCalledTimes(2);
+    expect(result.created).toHaveLength(2);
+    expect(result.errors).toHaveLength(0);
+    expect(mockLinker).toHaveBeenCalledWith("scan-1");
+  });
+
+  it("counts 'already exists' failures as skipped, not errors", () => {
+    mockGetSettingSync.mockReturnValue("true");
+    mockGetArtifacts.mockReturnValue([unlinkedSkill("gamma")]);
+    mockCreateProfile.mockImplementationOnce(() => {
+      throw new Error("profile already exists");
+    });
+
+    const result = autoPromoteUnlinkedSkills("scan-1");
+
+    expect(result.created).toEqual([]);
+    expect(result.skipped).toHaveLength(1);
+    expect(result.errors).toEqual([]);
+    // No re-link when nothing was created
+    expect(mockLinker).not.toHaveBeenCalled();
+  });
+
+  it("records non-duplicate errors and still re-links when some profiles succeeded", () => {
+    mockGetSettingSync.mockReturnValue("true");
+    mockGetArtifacts.mockReturnValue([
+      unlinkedSkill("delta"),
+      unlinkedSkill("epsilon"),
+    ]);
+    mockCreateProfile
+      .mockImplementationOnce(() => {
+        /* succeeds */
+      })
+      .mockImplementationOnce(() => {
+        throw new Error("disk full");
+      });
+
+    const result = autoPromoteUnlinkedSkills("scan-1");
+
+    expect(result.created).toHaveLength(1);
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].message).toBe("disk full");
+    expect(mockLinker).toHaveBeenCalledWith("scan-1");
+  });
+});

package/src/lib/environment/__tests__/list-skills-enriched.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi } from "vitest";
+
+vi.mock("../data", () => ({
+  getLatestScan: () => ({ id: "scan-1" }),
+  getArtifacts: () => [
+    {
+      id: "art-1",
+      scanId: "scan-1",
+      category: "skill",
+      tool: "claude-code",
+      scope: "user",
+      name: "code-reviewer",
+      relPath: ".claude/skills/code-reviewer",
+      absPath: "/u/.claude/skills/code-reviewer",
+      preview: "Review PRs",
+      sizeBytes: 100,
+      modifiedAt: new Date("2026-01-01T00:00:00Z").getTime(),
+      linkedProfileId: "code-reviewer-profile",
+      contentHash: "h",
+      metadata: null,
+      createdAt: new Date(),
+    },
+    {
+      id: "art-2",
+      scanId: "scan-1",
+      category: "skill",
+      tool: "codex",
+      scope: "user",
+      name: "code-reviewer",
+      relPath: ".agents/skills/code-reviewer",
+      absPath: "/u/.agents/skills/code-reviewer",
+      preview: "Review PRs",
+      sizeBytes: 100,
+      modifiedAt: new Date("2026-01-01T00:00:00Z").getTime(),
+      linkedProfileId: null,
+      contentHash: "h",
+      metadata: null,
+      createdAt: new Date(),
+    },
+  ],
+}));
+
+import { listSkillsEnriched } from "../list-skills";
+
+describe("listSkillsEnriched", () => {
+  it("returns enriched skills with syncStatus and linkedProfileId populated", () => {
+    const nowMs = new Date("2026-04-14T00:00:00Z").getTime();
+    const enriched = listSkillsEnriched({ nowMs });
+    expect(enriched).toHaveLength(1);
+    expect(enriched[0].name).toBe("code-reviewer");
+    expect(enriched[0].syncStatus).toBe("synced");
+    expect(enriched[0].linkedProfileId).toBe("code-reviewer-profile");
+    expect(enriched[0].healthScore).toBe("healthy");
+  });
+});

package/src/lib/environment/__tests__/skill-enrichment.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from "vitest";
+import {
+  computeHealthScore,
+  computeSyncStatus,
+  type HealthScore,
+  type SyncStatus,
+} from "../skill-enrichment";
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+describe("computeHealthScore", () => {
+  const NOW = new Date("2026-04-14T00:00:00Z").getTime();
+
+  it("returns 'healthy' for artifacts modified in the last 6 months", () => {
+    expect(computeHealthScore(NOW - 30 * MS_PER_DAY, NOW)).toBe("healthy");
+    expect(computeHealthScore(NOW - 179 * MS_PER_DAY, NOW)).toBe("healthy");
+  });
+
+  it("returns 'stale' for artifacts between 6 and 12 months old", () => {
+    expect(computeHealthScore(NOW - 200 * MS_PER_DAY, NOW)).toBe("stale");
+    expect(computeHealthScore(NOW - 364 * MS_PER_DAY, NOW)).toBe("stale");
+  });
+
+  it("returns 'aging' for artifacts over 12 months old", () => {
+    expect(computeHealthScore(NOW - 400 * MS_PER_DAY, NOW)).toBe("aging");
+  });
+
+  it("returns 'unknown' when modifiedAt is null", () => {
+    expect(computeHealthScore(null, NOW)).toBe("unknown");
+  });
+});
+
+describe("computeSyncStatus", () => {
+  it("returns 'synced' when both tools have the skill", () => {
+    expect(computeSyncStatus(["claude-code", "codex"])).toBe("synced");
+  });
+
+  it("returns 'claude-only' when only claude-code has it", () => {
+    expect(computeSyncStatus(["claude-code"])).toBe("claude-only");
+  });
+
+  it("returns 'codex-only' when only codex has it", () => {
+    expect(computeSyncStatus(["codex"])).toBe("codex-only");
+  });
+
+  it("returns 'shared' when only shared tool is present", () => {
+    expect(computeSyncStatus(["shared"])).toBe("shared");
+  });
+
+  it("returns 'synced' when claude + shared", () => {
+    expect(computeSyncStatus(["claude-code", "shared"])).toBe("synced");
+  });
+});
+
+import { enrichSkills, type EnrichedSkill } from "../skill-enrichment";
+import type { SkillSummary } from "../list-skills";
+
+const NOW = new Date("2026-04-14T00:00:00Z").getTime();
+const DAY = 24 * 60 * 60 * 1000;
+
+function skill(
+  id: string,
+  name: string,
+  tool: string,
+  overrides: Partial<SkillSummary> = {}
+): SkillSummary {
+  return {
+    id,
+    name,
+    tool,
+    scope: "user",
+    preview: "",
+    sizeBytes: 0,
+    absPath: `/tmp/${id}`,
+    ...overrides,
+  };
+}
+
+describe("enrichSkills", () => {
+  it("groups by name and computes syncStatus across tools", () => {
+    const out = enrichSkills(
+      [
+        skill("a", "research", "claude-code"),
+        skill("b", "research", "codex"),
+        skill("c", "standalone", "claude-code"),
+      ],
+      { modifiedAtMsByPath: {}, linkedProfilesByPath: {}, nowMs: NOW }
+    );
+    const bySkill: Record<string, EnrichedSkill> = {};
+    for (const s of out) bySkill[s.name] = s;
+    expect(bySkill.research.syncStatus).toBe("synced");
+    expect(bySkill.standalone.syncStatus).toBe("claude-only");
+  });
+
+  it("attaches linkedProfileId per artifact absPath", () => {
+    const out = enrichSkills(
+      [skill("x", "coder", "claude-code", { absPath: "/p/a" })],
+      {
+        modifiedAtMsByPath: {},
+        linkedProfilesByPath: { "/p/a": "code-reviewer" },
+        nowMs: NOW,
+      }
+    );
+    expect(out[0].linkedProfileId).toBe("code-reviewer");
+  });
+
+  it("assigns health from modifiedAtMsByPath", () => {
+    const out = enrichSkills(
+      [skill("x", "aging", "claude-code", { absPath: "/p/a" })],
+      {
+        modifiedAtMsByPath: { "/p/a": NOW - 400 * DAY },
+        linkedProfilesByPath: {},
+        nowMs: NOW,
+      }
+    );
+    expect(out[0].healthScore).toBe("aging");
+  });
+
+  it("merges duplicate absPaths (symlink case) to a single entry", () => {
+    const out = enrichSkills(
+      [
+        skill("a", "shared", "claude-code", { absPath: "/same" }),
+        skill("b", "shared", "codex", { absPath: "/same" }),
+      ],
+      { modifiedAtMsByPath: {}, linkedProfilesByPath: {}, nowMs: NOW }
+    );
+    expect(out).toHaveLength(1);
+  });
+});

package/src/lib/environment/__tests__/skill-recommendations.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest";
+import { computeRecommendation } from "../skill-recommendations";
+import type { EnrichedSkill } from "../skill-enrichment";
+
+const mkSkill = (
+  name: string,
+  preview: string,
+  overrides: Partial<EnrichedSkill> = {}
+): EnrichedSkill => ({
+  id: name,
+  name,
+  tool: "claude-code",
+  scope: "user",
+  preview,
+  sizeBytes: 0,
+  absPath: `/p/${name}`,
+  healthScore: "healthy",
+  syncStatus: "claude-only",
+  linkedProfileId: null,
+  absPaths: [`/p/${name}`],
+  ...overrides,
+});
+
+describe("computeRecommendation", () => {
+  it("recommends a healthy skill whose keywords match 2+ in recent messages", () => {
+    const skills = [
+      mkSkill("code-reviewer", "Review pull requests for security"),
+      mkSkill("researcher", "Search the web for up-to-date information"),
+    ];
+    const rec = computeRecommendation(skills, [
+      "can you review this pull request for security issues?",
+    ]);
+    expect(rec?.name).toBe("code-reviewer");
+  });
+
+  it("returns null when no strong keyword match exists", () => {
+    const skills = [mkSkill("code-reviewer", "Review PRs for security")];
+    const rec = computeRecommendation(skills, ["hi there"]);
+    expect(rec).toBeNull();
+  });
+
+  it("excludes already-active skill", () => {
+    const skills = [mkSkill("code-reviewer", "Review pull requests security")];
+    const rec = computeRecommendation(
+      skills,
+      ["review this pull request for security"],
+      { activeSkillId: "code-reviewer" }
+    );
+    expect(rec).toBeNull();
+  });
+
+  it("excludes dismissed skills", () => {
+    const skills = [mkSkill("code-reviewer", "Review pull requests security")];
+    const rec = computeRecommendation(
+      skills,
+      ["review pull request security issues"],
+      { dismissedIds: new Set(["code-reviewer"]) }
+    );
+    expect(rec).toBeNull();
+  });
+
+  it("excludes broken/aging skills", () => {
+    const skills = [
+      mkSkill("code-reviewer", "Review pull requests security", {
+        healthScore: "aging",
+      }),
+    ];
+    const rec = computeRecommendation(skills, [
+      "review pull request security issues",
+    ]);
+    expect(rec).toBeNull();
+  });
+
+  it("ignores stopwords and requires ≥2 distinct meaningful hits", () => {
+    const skills = [mkSkill("researcher", "the and for a of in on")];
+    const rec = computeRecommendation(skills, ["the and for a of in on"]);
+    expect(rec).toBeNull();
+  });
+
+  it("returns null on empty message list", () => {
+    const rec = computeRecommendation(
+      [mkSkill("code-reviewer", "review pull request security")],
+      []
+    );
+    expect(rec).toBeNull();
+  });
+});

package/src/lib/environment/data.ts

@@ -78,6 +78,15 @@ export function createScan(
     console.warn("[environment] Profile linking failed (non-blocking):", err);
   }
 
+  // Auto-promote unlinked skills to profiles if the user opted in.
+  // Imported lazily to avoid a top-level circular import with profile-generator.ts.
+  // Fire-and-forget: auto-promote runs asynchronously and failures are logged only.
+  import("./profile-generator")
+    .then((m) => m.autoPromoteUnlinkedSkills(scanId))
+    .catch((err) =>
+      console.warn("[environment] Auto-promote failed (non-blocking):", err)
+    );
+
   return db
     .select()
     .from(environmentScans)