Add always-on skills for new tasks

packages/core/src/sessions/cloudArtifactService.test.ts

@@ -165,7 +165,13 @@ describe("CloudArtifactService", () => {
       "task-1",
       "run-1",
       [],
-      [{ name: "local-skill", source: "user", path: "/tmp/local-skill" }],
+      [
+        {
+          name: "local-skill",
+          source: "user",
+          path: "/tmp/local-skill",
+        },
+      ],
     );
 
     expect(ids).toEqual(["skill-artifact-1"]);

packages/core/src/sessions/cloudArtifactService.ts

@@ -232,8 +232,6 @@ export class CloudArtifactService {
     if (skillBundleRefs.length === 0) {
       return [];
     }
-    // Pull in dependency skills the tagged ones declare, so a skill that needs
-    // another arrives in the sandbox together with it.
     const expandedRefs =
       await this.resolveSkillBundleDependencies(skillBundleRefs);
     return Promise.all(

packages/core/src/task-detail/taskCreationHost.ts

@@ -1,6 +1,11 @@
 import type { ContentBlock } from "@agentclientprotocol/sdk";
 import type { CloudSkillBundleRef } from "@posthog/core/sessions/cloudArtifactIdentifiers";
-import type { Workspace, WorkspaceInfo, WorkspaceMode } from "@posthog/shared";
+import type {
+  AlwaysOnSkillRef,
+  Workspace,
+  WorkspaceInfo,
+  WorkspaceMode,
+} from "@posthog/shared";
 import type { TaskCreationApiClient } from "./taskCreationApiClient";
 
 export interface CloudPromptTransport {
@@ -103,6 +108,9 @@ export interface ITaskCreationHost {
    * too, or a typed `/my-skill` reaches the sandbox with no bundle attached.
    */
   resolveLocalSkillCommandPrompt(prompt: string): Promise<string>;
+  renderAlwaysOnSkillInstructions(
+    skills: AlwaysOnSkillRef[],
+  ): Promise<string | undefined>;
   /**
    * Return-and-clear the pre-warmed sandbox lease matching the composer
    * selection, if one was provisioned while the user typed. The saga uploads

packages/core/src/task-detail/taskCreationSaga.test.ts

@@ -21,6 +21,7 @@ const mockHost = vi.hoisted(() => ({
   detectRepo: vi.fn(),
   getCloudPromptTransport: vi.fn(),
   resolveLocalSkillCommandPrompt: vi.fn(async (prompt: string) => prompt),
+  renderAlwaysOnSkillInstructions: vi.fn(),
   takeWarmTaskLease: vi.fn(
     (): { taskId: string; runId: string } | null => null,
   ),
@@ -118,6 +119,7 @@ describe("TaskCreationSaga", () => {
     mockHost.getWorkspace.mockResolvedValue(null);
     mockHost.getFolders.mockResolvedValue([]);
     mockHost.uploadRunAttachments.mockResolvedValue([]);
+    mockHost.renderAlwaysOnSkillInstructions.mockResolvedValue(undefined);
     mockHost.linkTaskBranch.mockResolvedValue(undefined);
     mockHost.recordClaudeCliImport.mockResolvedValue(undefined);
     mockHost.deleteClaudeCliImport.mockResolvedValue(undefined);
@@ -243,6 +245,49 @@ describe("TaskCreationSaga", () => {
     );
   });
 
+  it("folds always-on skill instructions into the first cloud message", async () => {
+    const startedTask = createTask({ latest_run: createRun() });
+    const startTaskRun = vi.fn().mockResolvedValue(startedTask);
+    mockHost.renderAlwaysOnSkillInstructions.mockResolvedValue(
+      "<always_on_skills>Be concise.</always_on_skills>",
+    );
+
+    const saga = makeSaga({
+      createTask: vi.fn().mockResolvedValue(createTask()),
+      createTaskRun: vi.fn().mockResolvedValue(createRun()),
+      startTaskRun,
+    });
+    const skill = {
+      name: "concise",
+      source: "user" as const,
+      path: "/skills/concise",
+    };
+
+    const result = await saga.run({
+      content: "Ship the fix",
+      repository: "posthog/posthog",
+      workspaceMode: "cloud",
+      alwaysOnSkills: [skill],
+    });
+
+    expect(result.success).toBe(true);
+    expect(mockHost.renderAlwaysOnSkillInstructions).toHaveBeenCalledWith([
+      skill,
+    ]);
+    expect(startTaskRun).toHaveBeenCalledWith(
+      "task-123",
+      "run-123",
+      expect.objectContaining({
+        pendingUserMessage:
+          "Ship the fix\n\n<always_on_skills>Be concise.</always_on_skills>",
+      }),
+    );
+    expect(mockHost.getCloudPromptTransport).toHaveBeenCalledWith(
+      "Ship the fix",
+      undefined,
+    );
+  });
+
   it("folds custom personalization into the cloud prompt and stashes it for the optimistic placeholder", async () => {
     const createdTask = createTask();
     const startedTask = createTask({ latest_run: createRun() });
@@ -353,6 +398,37 @@ describe("TaskCreationSaga", () => {
     );
   });
 
+  it("adds always-on skill instructions to the initial local prompt", async () => {
+    mockHost.renderAlwaysOnSkillInstructions.mockResolvedValue(
+      "<always_on_skills>Be concise.</always_on_skills>",
+    );
+    const saga = makeSaga({
+      createTask: vi.fn().mockResolvedValue(createTask()),
+    });
+
+    const result = await saga.run({
+      content: "Ship the fix",
+      workspaceMode: "local",
+      allowNoRepo: true,
+      alwaysOnSkills: [
+        { name: "concise", source: "user", path: "/skills/concise" },
+      ],
+    });
+
+    expect(result.success).toBe(true);
+    const connectParams = vi.mocked(sessionService.connectToTask).mock
+      .calls[0][0];
+    expect(connectParams.initialPrompt).toEqual(
+      expect.arrayContaining([
+        {
+          type: "text",
+          text: "<always_on_skills>Be concise.</always_on_skills>",
+        },
+      ]),
+    );
+    expect(connectParams).not.toHaveProperty("alwaysOnSkills");
+  });
+
   it("starts a Pi session without creating an ACP session", async () => {
     const createdTask = createTask({ repository: undefined });
     const createTaskRequest = vi.fn().mockResolvedValue(createdTask);

packages/core/src/task-detail/taskCreationSaga.ts

@@ -1,6 +1,5 @@
 import { PI_THINKING_LEVELS } from "@posthog/agent/pi/types";
 import {
-  buildChannelContextBlock,
   buildChannelContextText,
   buildCustomInstructionsText,
   buildPromptBlocks,
@@ -54,6 +53,7 @@ interface WarmActivationPayload {
 function buildCloudFirstMessage(
   messageText: string | undefined,
   input: TaskCreationInput,
+  alwaysOnSkillInstructions?: string,
 ): { pendingUserMessage?: string; augmented: boolean } {
   const customInstructionsText = messageText
     ? buildCustomInstructionsText(input.customInstructions)
@@ -64,12 +64,21 @@ function buildCloudFirstMessage(
     input.channelContextId,
   );
   const pendingUserMessage =
-    [messageText, customInstructionsText, channelContextText]
+    [
+      messageText,
+      customInstructionsText,
+      alwaysOnSkillInstructions,
+      channelContextText,
+    ]
       .filter((part): part is string => !!part)
       .join("\n\n") || undefined;
   return {
     pendingUserMessage,
-    augmented: !!(customInstructionsText || channelContextText),
+    augmented: !!(
+      customInstructionsText ||
+      alwaysOnSkillInstructions ||
+      channelContextText
+    ),
   };
 }
 
@@ -99,10 +108,16 @@ export class TaskCreationSaga extends Saga<
     const importedClaude = isPiRuntime
       ? undefined
       : await this.importClaudeSession(input);
+    const alwaysOnSkills = input.alwaysOnSkills;
+    const alwaysOnSkillInstructions = alwaysOnSkills?.length
+      ? await this.readOnlyStep("render_always_on_skills", () =>
+          this.deps.host.renderAlwaysOnSkillInstructions(alwaysOnSkills),
+        )
+      : undefined;
 
     const warmPayload =
       !isPiRuntime && !taskId && input.workspaceMode === "cloud"
-        ? await this.prepareWarmActivation(input)
+        ? await this.prepareWarmActivation(input, alwaysOnSkillInstructions)
         : null;
 
     let task = taskId
@@ -387,7 +402,11 @@ export class TaskCreationSaga extends Saga<
 
           const { pendingUserMessage, augmented } = warmPayload
             ? warmPayload
-            : buildCloudFirstMessage(transport?.messageText, input);
+            : buildCloudFirstMessage(
+                transport?.messageText,
+                input,
+                alwaysOnSkillInstructions,
+              );
 
           // The sandbox echoes pendingUserMessage back once it boots; until then
           // the optimistic placeholder would show the bare task description with
@@ -511,13 +530,22 @@ export class TaskCreationSaga extends Saga<
       // Append the channel's CONTEXT.md as optional background, so tasks made
       // in a channel start with the shared context the agent would otherwise
       // have to rediscover. Kept after the user's prompt so the request leads.
-      const channelContextBlock = buildChannelContextBlock(
+      const channelContextText = buildChannelContextText(
         input.channelContext,
         input.channelName,
         input.channelContextId,
       );
-      if (initialPrompt && channelContextBlock) {
-        initialPrompt.push(channelContextBlock);
+      const supplementaryContext = [
+        alwaysOnSkillInstructions,
+        channelContextText,
+      ].filter((text): text is string => !!text);
+      if (initialPrompt) {
+        initialPrompt.push(
+          ...supplementaryContext.map((text) => ({
+            type: "text" as const,
+            text,
+          })),
+        );
       }
 
       await this.step({
@@ -531,7 +559,9 @@ export class TaskCreationSaga extends Saga<
             await this.deps.piRunner.create({
               taskId: task.id,
               cwd: agentCwd ?? "",
-              prompt: input.content ?? "",
+              prompt: [input.content, ...supplementaryContext]
+                .filter((text): text is string => !!text)
+                .join("\n\n"),
               model: input.model,
               thinkingLevel,
             });
@@ -708,6 +738,7 @@ export class TaskCreationSaga extends Saga<
   // deliver the first message without its attachments.
   private async prepareWarmActivation(
     input: TaskCreationInput,
+    alwaysOnSkillInstructions?: string,
   ): Promise<WarmActivationPayload | null> {
     if (!input.content && !input.filePaths?.length) {
       return null;
@@ -723,6 +754,7 @@ export class TaskCreationSaga extends Saga<
     const { pendingUserMessage, augmented } = buildCloudFirstMessage(
       transport.messageText,
       input,
+      alwaysOnSkillInstructions,
     );
     const base: WarmActivationPayload = {
       transport,

packages/core/src/task-detail/taskInput.ts

@@ -35,6 +35,7 @@ export interface PrepareTaskInputOptions {
   channelId?: string;
   channelContextId?: string;
   customInstructions?: string;
+  alwaysOnSkills?: TaskCreationInput["alwaysOnSkills"];
   autoPublishCloudRuns?: boolean;
   rtkEnabledCloud?: boolean;
   allowNoRepo?: boolean;
@@ -85,6 +86,7 @@ export function prepareTaskInput(
     channelId: options.channelId,
     channelContextId: options.channelContextId,
     customInstructions: isCloud ? options.customInstructions : undefined,
+    alwaysOnSkills: options.alwaysOnSkills,
     allowNoRepo: options.allowNoRepo,
     importedMcpServers: isCloud ? options.importedMcpServers : undefined,
     relayedMcpServers: isCloud ? options.relayedMcpServers : undefined,

packages/host-router/src/routers/skills.router.ts

@@ -14,6 +14,7 @@ import {
   readSkillFileInput,
   readSkillFileOutput,
   renameSkillFileInput,
+  renderAlwaysOnSkillsOutput,
   resolveSkillDependenciesInput,
   resolveSkillDependenciesOutput,
   saveSkillFileInput,
@@ -54,6 +55,14 @@ export const skillsRouter = router({
         .get<SkillsService>(SKILLS_SERVICE)
         .resolveSkillBundleDependencies(input),
     ),
+  renderAlwaysOn: publicProcedure
+    .input(resolveSkillDependenciesInput)
+    .output(renderAlwaysOnSkillsOutput)
+    .query(({ ctx, input }) =>
+      ctx.container
+        .get<SkillsService>(SKILLS_SERVICE)
+        .renderAlwaysOnSkillInstructions(input),
+    ),
   contents: publicProcedure
     .input(skillContentsInput)
     .output(skillContentsOutput)

packages/shared/src/index.ts

@@ -328,6 +328,7 @@ export type {
   SignalReportStatus,
 } from "./signal-types";
 export type {
+  AlwaysOnSkillTarget,
   ExportedSkill,
   ExportedSkillFile,
   SkillFileEntry,
@@ -336,6 +337,7 @@ export type {
   UploadableSkillSource,
 } from "./skills";
 export {
+  getApplicableAlwaysOnSkills,
   SKILL_EXISTS_MARKER,
   serializeSkillMarkdown,
   stripFrontmatter,
@@ -354,6 +356,7 @@ export {
   updateTaskAutomationSchema,
 } from "./task-automation";
 export type {
+  AlwaysOnSkillRef,
   TaskCreationInput,
   TaskCreationOutput,
 } from "./task-creation-domain";