@agent-native/core-corpus 0.203.1-nightly-20261007183952 → 0.203.1

package/corpus/templates/analytics/CHANGELOG.md

@@ -11,6 +11,10 @@ time from the command menu (Cmd+K → "What's new") or from Settings.
 - Save exact session replay screens as PNG screenshots.
 - Session replays can be saved as screenshots without the replay controls.
 
+### Improved
+
+- Agent dashboard edits are now checked against the live chart before they save, so the agent no longer reports a chart change that did not happen.
+
 ### Fixed
 
 - Collaborators see a consistent dashboard after simultaneous edits

package/corpus/templates/content/CHANGELOG.md

@@ -7,6 +7,8 @@ time from the command menu (Cmd+K → "What's new").
 
 ### Fixed
 
+- ChatGPT widget previews show saved document bodies without a Content session.
+- Documents opened in ChatGPT show their saved content right away.
 - ChatGPT widgets show saved document bodies in read-only mode without a Content session.
 - Fixed Content pages that opened to an error in ChatGPT widgets
 

package/corpus/templates/design/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable user-facing changes to Design are documented here. Open it any time
 from the command menu (Cmd+K → "What's new") or from Settings.
 
+## 2026-10-07
+
+### Fixed
+
+- Design keeps frame-relative positions and selections stable when moving or pasting layers.
+- Position values stay aligned with selected layers in layouts with body margins.
+
 ## 2026-10-06
 
 ### Added

package/corpus/templates/dispatch/.agents/skills/recurring-jobs/SKILL.md

@@ -46,10 +46,25 @@ and pass normalized action items to an app's idempotent `import` action.
 
 | Tool          | Action     | Purpose                                                    |
 | ------------- | ---------- | ---------------------------------------------------------- |
-| `manage-jobs` | `create`   | Create a recurring job (name, cron schedule, instructions) |
+| `manage-jobs` | `create`   | Create a recurring job (name, cron schedule, instructions); fails if the name exists |
 | `manage-jobs` | `list`     | List all jobs and their status                             |
 | `manage-jobs` | `update`   | Update schedule, instructions, or toggle enabled           |
 
+## Job files an app owns
+
+`create` never replaces an existing job file, so a name that collides with an
+app's file (Factory's `factories/<id>/<name>`) is refused instead of reset.
+An app that stores its own settings in a job's frontmatter marks the file with
+`triggerType`, which makes `list`, `update`, and `delete` skip it and sends the
+caller to `manage-automations`. Edit those files only through the owning app's
+actions, and patch fields in place; rebuilding a file from the fields the writer
+knows drops the rest while the job keeps running.
+
+Any write to a `jobs/` file that removes a frontmatter field other than run
+bookkeeping is recorded as a `job-fields-dropped` audit event (org admins read
+it with `list-audit-events` and `action: "job-fields-dropped"`). Its input names
+the writer, the dropped fields, and the agent thread and run that made it.
+
 ## UI Surface
 
 `/agent#jobs` is the stable compatibility URL for the Agent page's

package/corpus/templates/factory/actions/save-factory-automation.ts

@@ -24,11 +24,12 @@ import {
   readPromptVersion,
   replaceAutomationContentWithUserPrompt,
   scheduleCron,
+  stampAutomationTriggerType,
 } from "../server/lib/factory-automation-config.js";
 import {
   deleteFactoryAutomationVersionRow,
   insertFactoryAutomationVersionIfChanged,
-  resolvePromptVersionForSnapshot,
+  resolvePromptVersionAllocation,
   snapshotFromAutomationResource,
 } from "../server/lib/factory-automation-history.js";
 import { findFactoryAutomationDefinition } from "../server/lib/factory-automation-resources.js";
@@ -249,14 +250,17 @@ export default defineAction({
       input.displayName !== undefined
         ? input.displayName.trim() || null
         : previousSnapshot.displayName;
-    const resolvedPromptVersion = resolvePromptVersionForSnapshot(
-      {
+    const versionAllocation = await resolvePromptVersionAllocation({
+      automationId: definition.resource.id,
+      orgId,
+      next: {
         userPrompt: normalizedPrompt,
         displayName: nextDisplayName,
         config,
       },
-      previousSnapshot,
-    );
+      previous: previousSnapshot,
+    });
+    const resolvedPromptVersion = versionAllocation.promptVersion;
     let content = applyAutomationConfigFrontmatter(resource.content, config);
     content = replaceAutomationContentWithUserPrompt(
       content,
@@ -289,6 +293,13 @@ export default defineAction({
       input.factoryId,
     );
     content = setAutomationFrontmatterField(content, "appId", "factory");
+    const stamp = stampAutomationTriggerType(content, { orgId });
+    content = stamp.content;
+    if (stamp.skipped) {
+      console.warn(
+        `[save-factory-automation] ${input.name} stays untagged because ${stamp.skipped}.`,
+      );
+    }
     if (input.model !== undefined) {
       content = setAutomationFrontmatterField(
         content,
@@ -328,6 +339,7 @@ export default defineAction({
       nextContent: content,
       summary: "Automation save",
       source: "save",
+      version: versionAllocation.predecessorVersion ?? undefined,
     });
     let updated: Awaited<ReturnType<typeof resourcePutIfCurrent>> = null;
     let writeError: unknown;

package/corpus/templates/factory/server/lib/factory-automation-config.ts

@@ -490,6 +490,61 @@ export function restoreFactoryAutomationIdentityFields(
   return next;
 }
 
+export type AutomationTriggerStamp = {
+  content: string;
+  /** Why the file stays untagged; absent when it is tagged. */
+  skipped?: string;
+};
+
+/**
+ * Tags a job file with its trigger type so core treats it as an automation.
+ * The tag moves the scheduler from its legacy identity fallback to strict
+ * checks (`createdBy`, `runAs: creator`, and an `orgId` matching the owner),
+ * so a file is tagged only when it can pass them. Defaults the legacy path
+ * already assumes are written down; a creator is never invented.
+ */
+export function stampAutomationTriggerType(
+  content: string,
+  options: { orgId: string; triggerType?: string; identityFrom?: string },
+): AutomationTriggerStamp {
+  if (readFrontmatterValue(content, "triggerType") != null) return { content };
+  const read = (key: string) =>
+    readFrontmatterValue(content, key) ??
+    (options.identityFrom
+      ? readFrontmatterValue(options.identityFrom, key)
+      : undefined);
+  const createdBy = read("createdBy");
+  if (!createdBy) return { content, skipped: "it has no createdBy" };
+  const runAs = read("runAs") ?? "creator";
+  if (runAs !== "creator") {
+    return { content, skipped: `it runs as "${runAs}"` };
+  }
+  const orgId = read("orgId") ?? options.orgId;
+  if (orgId !== options.orgId) {
+    return {
+      content,
+      skipped: `its orgId is "${orgId}", not "${options.orgId}"`,
+    };
+  }
+  let next = content;
+  for (const [key, value] of [
+    ["createdBy", createdBy],
+    ["runAs", runAs],
+    ["orgId", orgId],
+  ] as const) {
+    if (readFrontmatterValue(next, key) == null) {
+      next = setAutomationFrontmatterField(next, key, value);
+    }
+  }
+  return {
+    content: setAutomationFrontmatterField(
+      next,
+      "triggerType",
+      options.triggerType ?? "schedule",
+    ),
+  };
+}
+
 export function applyAutomationConfigFrontmatter(
   content: string,
   config: FactoryAutomationConfig,

package/corpus/templates/factory/server/lib/factory-automation-history.ts

@@ -1,5 +1,7 @@
+import { fail } from "@agent-native/core/action";
+import { isUniqueViolation } from "@agent-native/core/db";
 import { type Resource } from "@agent-native/core/resources";
-import { and, desc, eq, lt } from "drizzle-orm";
+import { and, desc, eq, lt, max } from "drizzle-orm";
 
 import { getDb } from "../db/index.js";
 import { factoryAutomationVersions } from "../db/schema.js";
@@ -13,6 +15,7 @@ import {
   readFactoryAutomationConfig,
   readFrontmatterValue,
   readPromptVersion,
+  stampAutomationTriggerType,
 } from "./factory-automation-config.js";
 import { findFactoryAutomationByResourceId } from "./factory-automation-resources.js";
 import {
@@ -74,17 +77,73 @@ export function snapshotContentIdentity(
   });
 }
 
-export function resolvePromptVersionForSnapshot(
+async function maxStoredVersion(input: {
+  automationId: string;
+  orgId: string;
+}): Promise<number | null> {
+  const [row] = await getDb()
+    .select({ latest: max(factoryAutomationVersions.version) })
+    .from(factoryAutomationVersions)
+    .where(
+      and(
+        eq(factoryAutomationVersions.automationId, input.automationId),
+        eq(factoryAutomationVersions.orgId, input.orgId),
+      ),
+    );
+  return row?.latest ?? null;
+}
+
+/**
+ * The version number to store the previous content under. A file's own
+ * `promptVersion` is the right number until it falls behind its history: a
+ * file that lost its frontmatter reads as version 0, and storing that under a
+ * number the history already holds fails the whole save.
+ */
+export async function allocatePredecessorVersion(input: {
+  automationId: string;
+  orgId: string;
+  fileVersion: number;
+}): Promise<number> {
+  const stored = await maxStoredVersion(input);
+  const nextFree = stored === null ? 0 : stored + 1;
+  if (input.fileVersion >= nextFree) return input.fileVersion;
+  console.warn(
+    `[factory-automation-history] ${input.automationId} reports promptVersion ${input.fileVersion} but versions up to ${stored} are already stored; recording its previous content as version ${nextFree}.`,
+  );
+  return nextFree;
+}
+
+export type PromptVersionAllocation = {
+  /** The `promptVersion` the saved file carries. */
+  promptVersion: number;
+  /** Where the previous content is stored; null when nothing changed. */
+  predecessorVersion: number | null;
+};
+
+export async function resolvePromptVersionAllocation(input: {
+  automationId: string;
+  orgId: string;
   next: Pick<
     FactoryAutomationSnapshot,
     "userPrompt" | "displayName" | "config"
-  >,
-  previous: FactoryAutomationSnapshot,
-): number {
-  if (snapshotContentIdentity(previous) === snapshotContentIdentity(next)) {
-    return previous.promptVersion;
+  >;
+  previous: FactoryAutomationSnapshot;
+}): Promise<PromptVersionAllocation> {
+  if (
+    snapshotContentIdentity(input.previous) ===
+    snapshotContentIdentity(input.next)
+  ) {
+    return {
+      promptVersion: input.previous.promptVersion,
+      predecessorVersion: null,
+    };
   }
-  return previous.promptVersion + 1;
+  const predecessorVersion = await allocatePredecessorVersion({
+    automationId: input.automationId,
+    orgId: input.orgId,
+    fileVersion: input.previous.promptVersion,
+  });
+  return { promptVersion: predecessorVersion + 1, predecessorVersion };
 }
 
 export type FactoryAutomationVersionRow = {
@@ -115,17 +174,26 @@ export async function insertFactoryAutomationVersionRow(input: {
   content: string;
   summary: string;
   source: FactoryAutomationVersionSource;
+  /** Pre-allocated by `resolvePromptVersionAllocation`; allocated here when omitted. */
+  version?: number;
 }): Promise<FactoryAutomationVersionRow> {
   const snapshot = snapshotFromAutomationResource(
     input.content,
     input.automationName,
     input.factoryId,
   );
+  const version =
+    input.version ??
+    (await allocatePredecessorVersion({
+      automationId: input.automationId,
+      orgId: input.orgId,
+      fileVersion: snapshot.promptVersion,
+    }));
   const row: FactoryAutomationVersionRow = {
     id: createVersionId(),
     automationId: input.automationId,
     factoryId: input.factoryId,
-    version: snapshot.promptVersion,
+    version,
     rawContent: input.content,
     displayName: snapshot.displayName,
     source: input.source,
@@ -135,7 +203,21 @@ export async function insertFactoryAutomationVersionRow(input: {
     ownerEmail: input.userEmail,
     orgId: input.orgId,
   };
-  await getDb().insert(factoryAutomationVersions).values(row);
+  try {
+    await getDb().insert(factoryAutomationVersions).values(row);
+  } catch (error) {
+    // Drizzle wraps the driver error, so the constraint code is on `cause`.
+    if (
+      isUniqueViolation(error) ||
+      isUniqueViolation((error as { cause?: unknown }).cause)
+    ) {
+      fail(
+        "Another change to this automation was saved at the same time. Refresh and try again.",
+        { statusCode: 409, errorCode: "automation_version_conflict" },
+      );
+    }
+    throw error;
+  }
   return row;
 }
 
@@ -149,6 +231,7 @@ export async function insertFactoryAutomationVersionIfChanged(input: {
   nextContent: string;
   summary: string;
   source: FactoryAutomationVersionSource;
+  version?: number;
 }): Promise<FactoryAutomationVersionRow | null> {
   const previousSnapshot = snapshotFromAutomationResource(
     input.previousContent,
@@ -175,6 +258,7 @@ export async function insertFactoryAutomationVersionIfChanged(input: {
     content: input.previousContent,
     summary: input.summary,
     source: input.source,
+    version: input.version,
   });
 }
 
@@ -305,10 +389,13 @@ export async function restoreFactoryAutomationVersion(input: {
     input.automationName,
     input.factoryId,
   );
-  const resolvedVersion = resolvePromptVersionForSnapshot(
-    restoredSnapshot,
-    previousSnapshot,
-  );
+  const allocation = await resolvePromptVersionAllocation({
+    automationId: input.automationId,
+    orgId: input.orgId,
+    next: restoredSnapshot,
+    previous: previousSnapshot,
+  });
+  const resolvedVersion = allocation.promptVersion;
   const configSavedAt = new Date().toISOString();
 
   let content = preserveOperationalFrontmatterFields(
@@ -335,6 +422,20 @@ export async function restoreFactoryAutomationVersion(input: {
     "factoryId",
     input.factoryId,
   );
+  // Versions saved before the stamp existed lack it; restoring one must not
+  // take it off the live file, nor tag a file that cannot pass the strict
+  // identity check.
+  const stamp = stampAutomationTriggerType(content, {
+    orgId: input.orgId,
+    triggerType: readFrontmatterValue(current.content, "triggerType"),
+    identityFrom: current.content,
+  });
+  content = stamp.content;
+  if (stamp.skipped) {
+    console.warn(
+      `[factory-automation-history] ${input.automationName} stays untagged after the restore because ${stamp.skipped}.`,
+    );
+  }
 
   const insertedVersion = await insertFactoryAutomationVersionIfChanged({
     automationId: input.automationId,
@@ -346,6 +447,7 @@ export async function restoreFactoryAutomationVersion(input: {
     nextContent: content,
     summary: input.summary,
     source: "restore",
+    version: allocation.predecessorVersion ?? undefined,
   });
 
   let updated: Awaited<ReturnType<typeof resourcePutIfCurrent>> = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core-corpus",
-  "version": "0.203.1-nightly-20261007183952",
+  "version": "0.203.1",
   "description": "Opt-in source corpus for Agent-Native Core source-search.",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {