stagent 0.10.0 → 0.11.0

package/src/lib/chat/types.ts

@@ -1,3 +1,9 @@
+import {
+  getRuntimeFeatures,
+  resolveAgentRuntime,
+  type RuntimeFeatures,
+} from "@/lib/agents/runtime/catalog";
+
 /** Screenshot attachment metadata stored in message metadata.attachments */
 export interface ScreenshotAttachment {
   documentId: string;
@@ -107,6 +113,15 @@ export function getRuntimeForModel(modelId: string): string {
   return /^(gpt|o\d)/.test(modelId) ? "openai-codex-app-server" : "claude-code";
 }
 
+/**
+ * Model → LLM-surface features. Thin wrapper around getRuntimeForModel +
+ * getRuntimeFeatures so chat callers don't need to know runtime IDs.
+ */
+export function getFeaturesForModel(modelId: string): RuntimeFeatures {
+  const runtimeId = resolveAgentRuntime(getRuntimeForModel(modelId));
+  return getRuntimeFeatures(runtimeId);
+}
+
 /** Suggested prompt category with expandable sub-prompts */
 export interface PromptCategory {
   id: string;

package/src/lib/constants/settings.ts

@@ -27,6 +27,8 @@ export const SETTINGS_KEYS = {
   SCHEDULE_MAX_CONCURRENT: "schedule.maxConcurrent",
   SCHEDULE_MAX_RUN_DURATION_SEC: "schedule.maxRunDurationSec",
   SCHEDULE_CHAT_PRESSURE_DELAY_SEC: "schedule.chatPressureDelaySec",
+  // Environment / profile sync
+  AUTO_PROMOTE_SKILLS: "environment.autoPromoteSkills",
 } as const;
 
 export type RoutingPreference = "cost" | "latency" | "quality" | "manual";

package/src/lib/data/clear.ts

@@ -55,9 +55,8 @@ const screenshotsDir = join(dataDir, "screenshots");
 
 /**
  * Wipe all data tables (FK-safe order) and uploaded files.
- * Preserves the settings table (auth config) and the license table
- * (paid tier activation) — clearing operational data should never
- * silently downgrade a paid instance back to community.
+ * Preserves the settings table (auth config) — clearing operational
+ * data should never silently reset user auth preferences.
  */
 export function clearAllData() {
   const sampleProfilesDeleted = clearSampleProfiles();
@@ -93,9 +92,6 @@ export function clearAllData() {
   const agentMessagesDeleted = db.delete(agentMessages).run().changes;
   const channelConfigsDeleted = db.delete(channelConfigs).run().changes;
 
-  // License table is intentionally preserved — clearing operational data
-  // should never downgrade a paid instance back to community tier.
-
   // Snapshots are intentionally preserved — they are backups, not working data
 
   const repoImportsDeleted = db.delete(repoImports).run().changes;

package/src/lib/db/bootstrap.ts

@@ -70,6 +70,9 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
       status TEXT DEFAULT 'planned' NOT NULL,
       assigned_agent TEXT,
       agent_profile TEXT,
+      effective_runtime_id TEXT,
+      effective_model_id TEXT,
+      runtime_fallback_reason TEXT,
       priority INTEGER DEFAULT 2 NOT NULL,
       result TEXT,
       session_id TEXT,
@@ -303,6 +306,9 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
 
   addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN agent_profile TEXT;`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_agent_profile ON tasks(agent_profile);`);
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN effective_runtime_id TEXT;`);
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN effective_model_id TEXT;`);
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN runtime_fallback_reason TEXT;`);
 
   addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN workflow_id TEXT REFERENCES workflows(id);`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_workflow_id ON tasks(workflow_id);`);
@@ -333,6 +339,15 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
   addColumnIfMissing(`ALTER TABLE documents ADD COLUMN source TEXT DEFAULT 'upload';`);
   addColumnIfMissing(`ALTER TABLE documents ADD COLUMN conversation_id TEXT REFERENCES conversations(id);`);
   addColumnIfMissing(`ALTER TABLE documents ADD COLUMN message_id TEXT;`);
+  // chat-ollama-native-skills: conversation-scoped active skill binding.
+  // Ollama can't use the SDK's native skill support, so we inject the
+  // selected skill's SKILL.md into Tier 0 of the system prompt on every
+  // turn while this column is set. Same machinery is usable from Claude
+  // and Codex as a programmatic skill-activation path.
+  addColumnIfMissing(`ALTER TABLE conversations ADD COLUMN active_skill_id TEXT;`);
+  // chat-skill-composition v1: array of additionally-activated skill IDs
+  // beyond the legacy active_skill_id. Default empty JSON array.
+  addColumnIfMissing(`ALTER TABLE conversations ADD COLUMN active_skill_ids TEXT DEFAULT '[]';`);
   // Workflow step delays — resume_at for schedule-based delay resumption.
   // The partial index on resume_at is created by migration 0024 for fresh DBs;
   // existing DBs that don't run migrations will do a small table scan instead.
@@ -455,6 +470,8 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
       status TEXT DEFAULT 'active' NOT NULL,
       session_id TEXT,
       context_scope TEXT,
+      active_skill_id TEXT,
+      active_skill_ids TEXT DEFAULT '[]',
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL,
       FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE NO ACTION ON DELETE NO ACTION

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"),
@@ -542,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(),
   },

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)