Skip to content

The open-source app everyone uses to manage agents at work

feat(server): preserve task timestamps and hierarchy through company import/export (#11193)

Devin Foley35aaaa0bd030
diff --git a/packages/shared/src/types/company-portability.ts b/packages/shared/src/types/company-portability.ts
index 3cc0eb4a6f..a32486b42f 100644
--- a/packages/shared/src/types/company-portability.ts
+++ b/packages/shared/src/types/company-portability.ts
@@ -200,6 +200,14 @@ export interface CompanyPortabilityIssueManifestEntry {
workProducts?: CompanyPortabilityIssueWorkProductManifestEntry[];
monitor?: CompanyPortabilityIssueMonitorManifestEntry | null;
attachments?: CompanyPortabilityIssueAttachmentManifestEntry[];
+ /** Slug of the parent task when it is part of the same bundle (schemaVersion >= 7). */
+ parentSlug?: string | null;
+ /** Preserved source timestamps as ISO strings (schemaVersion >= 7); absent in older bundles. */
+ createdAt?: string | null;
+ updatedAt?: string | null;
+ startedAt?: string | null;
+ completedAt?: string | null;
+ cancelledAt?: string | null;
metadata: Record<string, unknown> | null;
}
diff --git a/packages/shared/src/validators/company-portability.ts b/packages/shared/src/validators/company-portability.ts
index eb766e8ecf..dcd1bdc4db 100644
--- a/packages/shared/src/validators/company-portability.ts
+++ b/packages/shared/src/validators/company-portability.ts
@@ -222,6 +222,12 @@ export const portabilityIssueManifestEntrySchema = z.object({
workProducts: z.array(portabilityIssueWorkProductManifestEntrySchema).default([]),
monitor: portabilityIssueMonitorManifestEntrySchema.nullable().default(null),
attachments: z.array(portabilityIssueAttachmentManifestEntrySchema).default([]),
+ parentSlug: z.string().min(1).nullable().optional(),
+ createdAt: z.string().datetime().nullable().optional(),
+ updatedAt: z.string().datetime().nullable().optional(),
+ startedAt: z.string().datetime().nullable().optional(),
+ completedAt: z.string().datetime().nullable().optional(),
+ cancelledAt: z.string().datetime().nullable().optional(),
metadata: z.record(z.string(), z.unknown()).nullable(),
});
diff --git a/server/src/__tests__/company-portability-import-batching.test.ts b/server/src/__tests__/company-portability-import-batching.test.ts
index 53ed945bc1..0c7226aa74 100644
--- a/server/src/__tests__/company-portability-import-batching.test.ts
+++ b/server/src/__tests__/company-portability-import-batching.test.ts
@@ -157,7 +157,7 @@ interface SyntheticBundleOptions {
documentsPerIssue: number;
}
-/** Build an inline import bundle with the requested shape, valid at schemaVersion 6. */
+/** Build an inline import bundle with the requested shape, valid at schemaVersion 7. */
function buildSyntheticBundle(options: SyntheticBundleOptions): {
rootPath: string;
files: Record<string, CompanyPortabilityFileEntry>;
@@ -193,7 +193,7 @@ function buildSyntheticBundle(options: SyntheticBundleOptions): {
};
}
- files[".paperclip.yaml"] = renderPaperclipYaml({ schemaVersion: 6, tasks });
+ files[".paperclip.yaml"] = renderPaperclipYaml({ schemaVersion: 7, tasks });
return { rootPath: "batching-bench", files };
}
@@ -223,7 +223,7 @@ function buildTouchedIssuesBundle(issueCount: number): {
};
}
- files[".paperclip.yaml"] = renderPaperclipYaml({ schemaVersion: 6, tasks });
+ files[".paperclip.yaml"] = renderPaperclipYaml({ schemaVersion: 7, tasks });
return { rootPath: "inbox-flood", files };
}
@@ -423,6 +423,152 @@ describeEmbeddedPostgres("company import batches inserts", () => {
expect(imported?.startedAt).toBeNull();
});
+ it("preserves bundle timestamps and parent hierarchy through a real import", async () => {
+ const files: Record<string, CompanyPortabilityFileEntry> = {};
+ files["COMPANY.md"] = ['---', 'schema: "agentcompanies/v1"', 'name: "Timestamp Fidelity Co"', '---', '', 'Synthetic import bundle.', ''].join("\n");
+ const taskFile = (name: string) => ['---', `name: "${name}"`, "kind: task", '---', '', `${name} body.`, ''].join("\n");
+ files["tasks/a-child/TASK.md"] = taskFile("Child");
+ files["tasks/m-grandchild/TASK.md"] = taskFile("Grandchild");
+ files["tasks/z-parent/TASK.md"] = taskFile("Parent");
+ files[".paperclip.yaml"] = renderPaperclipYaml({
+ schemaVersion: 7,
+ tasks: {
+ // The child slug sorts before its parent so the importer's
+ // parents-first row ordering (not manifest order) must satisfy the
+ // parent foreign key.
+ "a-child": {
+ status: "todo",
+ priority: "medium",
+ parent: "z-parent",
+ createdAt: "2026-01-05T00:00:00.000Z",
+ updatedAt: "2026-03-05T00:00:00.000Z",
+ comments: [{
+ body: "Older than the preserved updatedAt.",
+ authorType: "system",
+ createdAt: "2026-02-01T00:00:00.000Z",
+ }],
+ },
+ "m-grandchild": {
+ status: "todo",
+ priority: "medium",
+ parent: "a-child",
+ createdAt: "2026-01-06T00:00:00.000Z",
+ updatedAt: "2026-01-07T00:00:00.000Z",
+ },
+ "z-parent": {
+ status: "done",
+ priority: "medium",
+ createdAt: "2026-01-01T00:00:00.000Z",
+ updatedAt: "2026-03-01T00:00:00.000Z",
+ completedAt: "2026-02-20T00:00:00.000Z",
+ comments: [{
+ body: "Newer than the preserved updatedAt.",
+ authorType: "system",
+ createdAt: "2026-04-01T00:00:00.000Z",
+ }],
+ },
+ },
+ });
+
+ const portability = companyPortabilityService(db);
+ const result = await portability.importBundle(
+ {
+ source: { type: "inline", rootPath: "timestamp-fidelity", files },
+ include: { company: true, agents: false, projects: false, issues: true },
+ target: { mode: "new_company", newCompanyName: "Timestamp Fidelity Co" },
+ collisionStrategy: "rename",
+ },
+ "user-timestamp-fidelity",
+ );
+ expect(result.warnings).toEqual([]);
+
+ const rows = await db
+ .select({
+ id: issues.id,
+ title: issues.title,
+ parentId: issues.parentId,
+ createdAt: issues.createdAt,
+ updatedAt: issues.updatedAt,
+ startedAt: issues.startedAt,
+ completedAt: issues.completedAt,
+ })
+ .from(issues)
+ .where(eq(issues.companyId, result.company.id));
+ const parent = rows.find((row) => row.title === "Parent")!;
+ const child = rows.find((row) => row.title === "Child")!;
+ const grandchild = rows.find((row) => row.title === "Grandchild")!;
+
+ // The parent chain of three lands intact.
+ expect(parent.parentId).toBeNull();
+ expect(child.parentId).toBe(parent.id);
+ expect(grandchild.parentId).toBe(child.id);
+
+ expect(parent.createdAt).toEqual(new Date("2026-01-01T00:00:00.000Z"));
+ expect(parent.completedAt).toEqual(new Date("2026-02-20T00:00:00.000Z"));
+ expect(parent.startedAt).toBeNull();
+ expect(child.createdAt).toEqual(new Date("2026-01-05T00:00:00.000Z"));
+ expect(grandchild.createdAt).toEqual(new Date("2026-01-06T00:00:00.000Z"));
+ expect(grandchild.updatedAt).toEqual(new Date("2026-01-07T00:00:00.000Z"));
+
+ // A comment older than the preserved updatedAt must not regress it...
+ expect(child.updatedAt).toEqual(new Date("2026-03-05T00:00:00.000Z"));
+ // ...while a newer imported comment still bumps recency forward.
+ expect(parent.updatedAt).toEqual(new Date("2026-04-01T00:00:00.000Z"));
+ });
+
+ it("imports a v6 bundle without the timestamp fields using import-time defaults", async () => {
+ // A little slack absorbs clock drift between this process and Postgres.
+ const importStart = Date.now() - 1_000;
+ const files: Record<string, CompanyPortabilityFileEntry> = {};
+ files["COMPANY.md"] = ['---', 'schema: "agentcompanies/v1"', 'name: "Legacy Shape Co"', '---', '', 'Synthetic import bundle.', ''].join("\n");
+ files["tasks/legacy-task/TASK.md"] = ['---', 'name: "Legacy task"', "kind: task", '---', '', 'Legacy body.', ''].join("\n");
+ files[".paperclip.yaml"] = renderPaperclipYaml({
+ schemaVersion: 6,
+ tasks: {
+ "legacy-task": {
+ status: "todo",
+ priority: "medium",
+ comments: [{
+ body: "Predates the import.",
+ authorType: "system",
+ createdAt: "2026-01-01T00:00:00.000Z",
+ }],
+ },
+ },
+ });
+
+ const portability = companyPortabilityService(db);
+ const result = await portability.importBundle(
+ {
+ source: { type: "inline", rootPath: "legacy-shape", files },
+ include: { company: true, agents: false, projects: false, issues: true },
+ target: { mode: "new_company", newCompanyName: "Legacy Shape Co" },
+ collisionStrategy: "rename",
+ },
+ "user-legacy-shape",
+ );
+ expect(result.warnings).toContain(
+ "This package declares schemaVersion 6 and predates task timestamp and parent link transfer; that task data imports only if the bundle carries it.",
+ );
+
+ const [row] = await db
+ .select({
+ parentId: issues.parentId,
+ createdAt: issues.createdAt,
+ updatedAt: issues.updatedAt,
+ startedAt: issues.startedAt,
+ })
+ .from(issues)
+ .where(eq(issues.companyId, result.company.id));
+ expect(row?.parentId).toBeNull();
+ expect(row?.startedAt).toBeNull();
+ // Without preserved timestamps the row keeps the old behavior: created and
+ // updated at import time, and the comment bump does not drag updatedAt
+ // back to the older comment createdAt.
+ expect(row!.createdAt.getTime()).toBeGreaterThanOrEqual(importStart);
+ expect(row!.updatedAt.getTime()).toBeGreaterThanOrEqual(importStart);
+ });
+
it("rolls back the whole work-product batch when a later chunk fails", async () => {
// Seed a real company + issue to hang work products off of.
const bundle = buildSyntheticBundle({ issueCount: 1, commentsPerIssue: 0, documentsPerIssue: 0 });
diff --git a/server/src/__tests__/company-portability.test.ts b/server/src/__tests__/company-portability.test.ts
index 9631ddd3b7..494087e704 100644
--- a/server/src/__tests__/company-portability.test.ts
+++ b/server/src/__tests__/company-portability.test.ts
@@ -3579,8 +3579,8 @@ describe("company portability", () => {
expect(extension).not.toContain("labelIds");
expect(extension).not.toContain("label-a");
// Fresh exports declare the current bundle shape end-to-end.
- expect(extension).toContain("schemaVersion: 6");
- expect(exported.manifest.schemaVersion).toBe(6);
+ expect(extension).toContain("schemaVersion: 7");
+ expect(exported.manifest.schemaVersion).toBe(7);
expect(exported.manifest.labels).toEqual([
{ name: "bug", color: "#ff0000" },
{ name: "urgent", color: "#00ff00" },
@@ -4030,6 +4030,207 @@ describe("company portability", () => {
);
});
+ function mockTaskHierarchyExportSources() {
+ projectSvc.list.mockResolvedValue([]);
+ projectSvc.listWorkspaces.mockResolvedValue([]);
+ const baseIssue = {
+ description: null,
+ projectId: null,
+ projectWorkspaceId: null,
+ assigneeAgentId: null,
+ priority: "medium",
+ labelIds: [],
+ billingCode: null,
+ executionWorkspaceSettings: null,
+ assigneeAdapterOverrides: null,
+ };
+ issueSvc.list.mockResolvedValue([
+ {
+ ...baseIssue,
+ id: "issue-1",
+ identifier: "PAP-1",
+ title: "Alpha task",
+ status: "done",
+ parentId: null,
+ createdAt: new Date("2026-01-01T00:00:00.000Z"),
+ updatedAt: new Date("2026-03-01T00:00:00.000Z"),
+ startedAt: new Date("2026-01-02T00:00:00.000Z"),
+ completedAt: new Date("2026-02-01T00:00:00.000Z"),
+ },
+ {
+ ...baseIssue,
+ id: "issue-2",
+ identifier: "PAP-2",
+ title: "Beta task",
+ status: "todo",
+ parentId: "issue-1",
+ createdAt: new Date("2026-01-05T00:00:00.000Z"),
+ updatedAt: new Date("2026-01-06T00:00:00.000Z"),
+ },
+ {
+ ...baseIssue,
+ id: "issue-3",
+ identifier: "PAP-3",
+ title: "Gamma task",
+ status: "todo",
+ parentId: "issue-2",
+ createdAt: new Date("2026-01-07T00:00:00.000Z"),
+ updatedAt: new Date("2026-01-08T00:00:00.000Z"),
+ },
+ {
+ ...baseIssue,
+ id: "issue-4",
+ identifier: "PAP-4",
+ title: "Delta task",
+ status: "todo",
+ parentId: "issue-outside",
+ },
+ ]);
+ }
+
+ it("carries task timestamps and parent links through export and import", async () => {
+ const { db } = fakeImportDb();
+ const portability = companyPortabilityService(db);
+ mockTaskHierarchyExportSources();
+
+ const exported = await portability.exportBundle("company-1", {
+ include: { company: true, agents: false, projects: false, issues: true },
+ });
+
+ const extension = asTextFile(exported.files[".paperclip.yaml"]);
+ expect(extension).toContain("schemaVersion: 7");
+ expect(extension).toContain('parent: "pap-1"');
+ expect(extension).toContain('createdAt: "2026-01-01T00:00:00.000Z"');
+ expect(exported.warnings).toContain(
+ "1 parent relation references a task outside this export and was not included.",
+ );
+
+ const alphaEntry = exported.manifest.issues.find((issue) => issue.slug === "pap-1");
+ const betaEntry = exported.manifest.issues.find((issue) => issue.slug === "pap-2");
+ const gammaEntry = exported.manifest.issues.find((issue) => issue.slug === "pap-3");
+ const deltaEntry = exported.manifest.issues.find((issue) => issue.slug === "pap-4");
+ expect(alphaEntry).toEqual(expect.objectContaining({
+ parentSlug: null,
+ createdAt: "2026-01-01T00:00:00.000Z",
+ updatedAt: "2026-03-01T00:00:00.000Z",
+ startedAt: "2026-01-02T00:00:00.000Z",
+ completedAt: "2026-02-01T00:00:00.000Z",
+ cancelledAt: null,
+ }));
+ expect(betaEntry?.parentSlug).toBe("pap-1");
+ expect(gammaEntry?.parentSlug).toBe("pap-2");
+ // The unexported parent edge is dropped, not carried by raw id.
+ expect(deltaEntry?.parentSlug).toBeNull();
+ expect(extension).not.toContain("issue-outside");
+
+ companySvc.create.mockResolvedValue({ id: "company-imported", name: "Imported" });
+ accessSvc.ensureMembership.mockResolvedValue(undefined);
+ agentSvc.list.mockResolvedValue([]);
+
+ await portability.importBundle({
+ source: { type: "inline", rootPath: exported.rootPath, files: exported.files },
+ include: { company: true, agents: false, projects: false, issues: true },
+ target: { mode: "new_company", newCompanyName: "Imported" },
+ agents: "all",
+ collisionStrategy: "rename",
+ }, "user-1");
+
+ const importedRows = issueSvc.importIssues.mock.calls[0]![1] as Array<{
+ id: string;
+ title: string;
+ parentId: string | null;
+ createdAt: Date | null;
+ updatedAt: Date | null;
+ startedAt: Date | null;
+ completedAt: Date | null;
+ cancelledAt: Date | null;
+ }>;
+ const alphaRow = importedRows.find((row) => row.title === "Alpha task")!;
+ const betaRow = importedRows.find((row) => row.title === "Beta task")!;
+ const gammaRow = importedRows.find((row) => row.title === "Gamma task")!;
+ const deltaRow = importedRows.find((row) => row.title === "Delta task")!;
+
+ // Timestamps survive the round trip as concrete dates.
+ expect(alphaRow.createdAt).toEqual(new Date("2026-01-01T00:00:00.000Z"));
+ expect(alphaRow.updatedAt).toEqual(new Date("2026-03-01T00:00:00.000Z"));
+ expect(alphaRow.startedAt).toEqual(new Date("2026-01-02T00:00:00.000Z"));
+ expect(alphaRow.completedAt).toEqual(new Date("2026-02-01T00:00:00.000Z"));
+ expect(alphaRow.cancelledAt).toBeNull();
+ expect(betaRow.createdAt).toEqual(new Date("2026-01-05T00:00:00.000Z"));
+
+ // The parent chain of three is intact against the pre-generated ids.
+ expect(alphaRow.parentId).toBeNull();
+ expect(betaRow.parentId).toBe(alphaRow.id);
+ expect(gammaRow.parentId).toBe(betaRow.id);
+ expect(deltaRow.parentId).toBeNull();
+
+ // Rows arrive parents-first so chunked inserts satisfy the parent FK.
+ expect(importedRows.indexOf(alphaRow)).toBeLessThan(importedRows.indexOf(betaRow));
+ expect(importedRows.indexOf(betaRow)).toBeLessThan(importedRows.indexOf(gammaRow));
+ });
+
+ it("drops self-referencing and cyclic parent links from a hand-built bundle with warnings", async () => {
+ const { db } = fakeImportDb();
+ const portability = companyPortabilityService(db);
+
+ const taskFile = (name: string) => ["---", `name: "${name}"`, "kind: task", "---", "", `${name} body.`, ""].join("\n");
+ const files = {
+ "COMPANY.md": ["---", 'schema: "agentcompanies/v1"', 'name: "Tampered Import"', "---", ""].join("\n"),
+ "tasks/task-a/TASK.md": taskFile("Task A"),
+ "tasks/task-b/TASK.md": taskFile("Task B"),
+ "tasks/task-c/TASK.md": taskFile("Task C"),
+ ".paperclip.yaml": [
+ 'schema: "paperclip/v1"',
+ "schemaVersion: 7",
+ "tasks:",
+ " task-a:",
+ ' status: "todo"',
+ ' parent: "task-b"',
+ " task-b:",
+ ' status: "todo"',
+ ' parent: "task-a"',
+ " task-c:",
+ ' status: "todo"',
+ ' parent: "task-c"',
+ ' createdAt: "not-a-timestamp"',
+ "",
+ ].join("\n"),
+ };
+
+ companySvc.create.mockResolvedValue({ id: "company-imported", name: "Tampered Import" });
+ accessSvc.ensureMembership.mockResolvedValue(undefined);
+ agentSvc.list.mockResolvedValue([]);
+
+ const result = await portability.importBundle({
+ source: { type: "inline", rootPath: "tampered-package", files },
+ include: { company: true, agents: false, projects: false, issues: true },
+ target: { mode: "new_company", newCompanyName: "Tampered Import" },
+ agents: "all",
+ collisionStrategy: "rename",
+ }, "user-1");
+
+ const importedRows = issueSvc.importIssues.mock.calls[0]![1] as Array<{
+ title: string;
+ parentId: string | null;
+ createdAt: Date | null;
+ }>;
+ const rowA = importedRows.find((row) => row.title === "Task A")!;
+ const rowB = importedRows.find((row) => row.title === "Task B")!;
+ const rowC = importedRows.find((row) => row.title === "Task C")!;
+
+ // One direction of the two-task cycle survives; the closing edge drops.
+ expect([rowA.parentId, rowB.parentId].filter((parentId) => parentId !== null)).toHaveLength(1);
+ expect(rowC.parentId).toBeNull();
+ expect(rowC.createdAt).toBeNull();
+ expect(result.warnings.filter((warning) => warning.includes("would create a parent cycle"))).toHaveLength(2);
+ expect(result.warnings).toContain(
+ "Task task-c parent task-c was skipped because it would create a parent cycle.",
+ );
+ expect(result.warnings).toContain(
+ "Task task-c createdAt was ignored because it is not a valid timestamp.",
+ );
+ });
+
const attachmentBytesByObjectKey: Record<string, string> = {
"issues/issue-1/notes.bin": "png-bytes",
"issues/issue-1/screenshot.png": "png-bytes",
@@ -4625,7 +4826,7 @@ describe("company portability", () => {
it("imports unstamped v5 packages with an info warning about task data they predate", async () => {
const portability = companyPortabilityService({} as any);
const v5Warning =
- "This package declares schemaVersion 5 and predates label, blocker, document, work product, monitor, attachment, and embedded image transfer; that task data imports only if the bundle carries it.";
+ "This package declares schemaVersion 5 and predates label, blocker, document, work product, monitor, attachment, embedded image, task timestamp, and parent link transfer; that task data imports only if the bundle carries it.";
companySvc.create.mockResolvedValue({ id: "company-imported", name: "Legacy Import" });
accessSvc.ensureMembership.mockResolvedValue(undefined);
@@ -4674,7 +4875,7 @@ describe("company portability", () => {
const portability = companyPortabilityService({} as any);
await expect(portability.importBundle({
- source: { type: "inline", rootPath: "future-package", files: legacyPackageFiles(["schemaVersion: 7"]) },
+ source: { type: "inline", rootPath: "future-package", files: legacyPackageFiles(["schemaVersion: 8"]) },
include: { company: true, agents: false, projects: false, issues: true },
target: { mode: "new_company", newCompanyName: "Future Import" },
agents: "all",
diff --git a/server/src/services/company-portability.ts b/server/src/services/company-portability.ts
index cdf4cb5630..c86c2bbbef 100644
--- a/server/src/services/company-portability.ts
+++ b/server/src/services/company-portability.ts
@@ -161,8 +161,10 @@ const DEFAULT_INCLUDE: CompanyPortabilityInclude = {
const DEFAULT_COLLISION_STRATEGY: CompanyPortabilityCollisionStrategy = "rename";
// The bundle shape this build reads and writes. Bundles began declaring
// their schemaVersion in the .paperclip.yaml extension at 6; undeclared
-// bundles are read as 5, the last unstamped shape.
-const BUNDLE_SCHEMA_VERSION = 6;
+// bundles are read as 5, the last unstamped shape. 7 adds preserved task
+// timestamps and parent links; 5/6 bundles still import, with those fields
+// falling back to import-time defaults.
+const BUNDLE_SCHEMA_VERSION = 7;
const UNSTAMPED_BUNDLE_SCHEMA_VERSION = 5;
const DEFAULT_IMPORTED_LABEL_COLOR = "#6366f1";
// Blob entries are content-addressed by sha256; the store itself is
@@ -899,6 +901,38 @@ function readPortableIssueLabelNames(value: unknown): string[] {
return names;
}
+/**
+ * Read a preserved issue timestamp from the extension, validated the same way
+ * comment createdAt is (Date.parse). Invalid values are ignored with a
+ * warning — never a hard failure — so a hand-edited bundle still imports.
+ */
+function readPortableIssueTimestamp(
+ value: unknown,
+ warnings: string[],
+ sourceLabel: string,
+ fieldLabel: string,
+): string | null {
+ if (value === undefined || value === null) return null;
+ const raw = asString(value);
+ if (raw && !Number.isNaN(Date.parse(raw))) return raw;
+ warnings.push(`${sourceLabel} ${fieldLabel} was ignored because it is not a valid timestamp.`);
+ return null;
+}
+
+/** Render a stored timestamp as a portable ISO string, or omit it when unset/invalid. */
+function toPortableTimestamp(value: Date | string | null | undefined): string | undefined {
+ if (value == null) return undefined;
+ const date = value instanceof Date ? value : new Date(value);
+ return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+
+/** Convert a manifest timestamp (already validated at parse time) to a Date, or null. */
+function portableManifestDate(value: string | null | undefined): Date | null {
+ if (!value) return null;
+ const date = new Date(value);
+ return Number.isNaN(date.getTime()) ? null : date;
+}
+
function readPortableIssueBlockedBy(value: unknown): string[] {
if (!Array.isArray(value)) return [];
const slugs: string[] = [];
@@ -3353,6 +3387,12 @@ function buildManifestFromPackageFiles(
workProducts: normalizePortableIssueWorkProducts(extension.workProducts),
monitor: normalizePortableIssueMonitor(extension.monitor),
attachments: normalizePortableIssueAttachments(extension.attachments, warnings, `Task ${slug}`),
+ parentSlug: asString(extension.parent),
+ createdAt: readPortableIssueTimestamp(extension.createdAt, warnings, `Task ${slug}`, "createdAt"),
+ updatedAt: readPortableIssueTimestamp(extension.updatedAt, warnings, `Task ${slug}`, "updatedAt"),
+ startedAt: readPortableIssueTimestamp(extension.startedAt, warnings, `Task ${slug}`, "startedAt"),
+ completedAt: readPortableIssueTimestamp(extension.completedAt, warnings, `Task ${slug}`, "completedAt"),
+ cancelledAt: readPortableIssueTimestamp(extension.cancelledAt, warnings, `Task ${slug}`, "cancelledAt"),
metadata: isPlainRecord(extension.metadata) ? extension.metadata : null,
});
if (frontmatter.kind && frontmatter.kind !== "task") {
@@ -3361,7 +3401,10 @@ function buildManifestFromPackageFiles(
}
if (bundleSchemaVersion < BUNDLE_SCHEMA_VERSION && manifest.issues.length > 0) {
- warnings.push(`This package declares schemaVersion ${bundleSchemaVersion} and predates label, blocker, document, work product, monitor, attachment, and embedded image transfer; that task data imports only if the bundle carries it.`);
+ const predated = bundleSchemaVersion < 6
+ ? "label, blocker, document, work product, monitor, attachment, embedded image, task timestamp, and parent link transfer"
+ : "task timestamp and parent link transfer";
+ warnings.push(`This package declares schemaVersion ${bundleSchemaVersion} and predates ${predated}; that task data imports only if the bundle carries it.`);
}
manifest.envInputs = dedupeEnvInputs(manifest.envInputs);
@@ -4216,6 +4259,7 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {
}
let unexportedBlockerEdgeCount = 0;
+ let unexportedParentEdgeCount = 0;
let unportableWorkProductRefCount = 0;
const exportedBlobs = new Map<string, CompanyPortabilityBlobManifestEntry>();
for (const issue of selectedIssueRows) {
@@ -4256,6 +4300,13 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {
unexportedBlockerEdgeCount += relationSummaries.blocks
.filter((blocked) => !taskSlugByIssueId.has(blocked.id))
.length;
+ // Parent links travel by task slug like blockers; a parent outside the
+ // export selection drops the edge and is counted for one warning.
+ let parentTaskSlug: string | null = null;
+ if (issue.parentId) {
+ parentTaskSlug = taskSlugByIssueId.get(issue.parentId) ?? null;
+ if (!parentTaskSlug) unexportedParentEdgeCount += 1;
+ }
const issueDocumentRows = await documentsSvc.listIssueDocuments(issue.id, { includeSystem: true });
const documentEntries = issueDocumentRows.map((document) => {
const documentPath = `tasks/${taskSlug}/documents/${document.key}.md`;
@@ -4339,6 +4390,12 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {
identifier: issue.identifier,
status: issue.status,
priority: issue.priority,
+ parent: parentTaskSlug ?? undefined,
+ createdAt: toPortableTimestamp(issue.createdAt),
+ updatedAt: toPortableTimestamp(issue.updatedAt),
+ startedAt: toPortableTimestamp(issue.startedAt),
+ completedAt: toPortableTimestamp(issue.completedAt),
+ cancelledAt: toPortableTimestamp(issue.cancelledAt),
// Labels travel by name (their natural key); the bundle-level labels
// section carries the matching color definitions.
labels: (issue.labelIds ?? [])
@@ -4380,6 +4437,9 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {
if (unexportedBlockerEdgeCount > 0) {
warnings.push(`${unexportedBlockerEdgeCount} blocker relation${unexportedBlockerEdgeCount === 1 ? " references a task" : "s reference tasks"} outside this export and ${unexportedBlockerEdgeCount === 1 ? "was" : "were"} not included.`);
}
+ if (unexportedParentEdgeCount > 0) {
+ warnings.push(`${unexportedParentEdgeCount} parent relation${unexportedParentEdgeCount === 1 ? " references a task" : "s reference tasks"} outside this export and ${unexportedParentEdgeCount === 1 ? "was" : "were"} not included.`);
+ }
if (unportableWorkProductRefCount > 0) {
warnings.push(`${unportableWorkProductRefCount} work product${unportableWorkProductRefCount === 1 ? " references" : "s reference"} execution workspaces or runs that are not portable; those references were omitted from the export.`);
}
@@ -5721,6 +5781,7 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {
const importedIssueIdBySlug = new Map<string, string>();
const blockedByBySlug = new Map<string, string[]>();
+ const parentSlugBySlug = new Map<string, string>();
let unarmedMonitorCount = 0;
let attachmentsSkippedNoStorage = 0;
const attachmentMaxBytes = normalizeIssueAttachmentMaxBytes(targetCompany.attachmentMaxBytes ?? null);
@@ -5924,6 +5985,9 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {
if ((manifestIssue.blockedBy ?? []).length > 0) {
blockedByBySlug.set(manifestIssue.slug, manifestIssue.blockedBy ?? []);
}
+ if (manifestIssue.parentSlug) {
+ parentSlugBySlug.set(manifestIssue.slug, manifestIssue.parentSlug);
+ }
for (const documentEntry of manifestIssue.documents ?? []) {
const documentBody = readPortableTextFile(plan.source.files, documentEntry.path);
if (documentBody === null) {
@@ -6050,9 +6114,70 @@ export function companyPortabilityService(db: Db, storage?: StorageService) {
labelIds: resolvedLabelIds,
monitorNotes,
monitorScheduledBy,
+ parentId: null,
+ createdAt: portableManifestDate(manifestIssue.createdAt),
+ updatedAt: portableManifestDate(manifestIssue.updatedAt),
+ startedAt: portableManifestDate(manifestIssue.startedAt),
+ completedAt: portableManifestDate(manifestIssue.completedAt),
+ cancelledAt: portableManifestDate(manifestIssue.cancelledAt),
});
}
+ // Parent links resolve against the pre-generated ids before the flush
+ // so each issue row carries its parentId on insert. Edges whose parent
+ // was not imported, self-references, and cycles (possible only in a
+ // hand-edited bundle) drop with a warning, mirroring blocker handling.
+ if (parentSlugBySlug.size > 0) {
+ const rowBySlug = new Map(issueRows.map((row) => [row.ref, row] as const));
+ const acceptedParentById = new Map<string, string>();
+ const wouldCreateParentCycle = (childId: string, parentId: string) => {
+ let current: string | undefined = parentId;
+ const visited = new Set<string>();
+ while (current) {
+ if (current === childId) return true;
+ if (visited.has(current)) return false;
+ visited.add(current);
+ current = acceptedParentById.get(current);
+ }
+ return false;
+ };
+ for (const [slug, parentSlug] of parentSlugBySlug) {
+ const row = rowBySlug.get(slug);
+ if (!row) continue;
+ const parentId = importedIssueIdBySlug.get(parentSlug);
+ if (!parentId) {
+ warnings.push(`Task ${slug} parent ${parentSlug} was skipped because that task was not imported.`);
+ continue;
+ }
+ if (parentId === row.id || wouldCreateParentCycle(row.id, parentId)) {
+ warnings.push(`Task ${slug} parent ${parentSlug} was skipped because it would create a parent cycle.`);
+ continue;
+ }
+ acceptedParentById.set(row.id, parentId);
+ row.parentId = parentId;
+ }
+ // The parent foreign key is checked per insert statement, so order
+ // rows parents-first: a child must never land in an earlier chunk
+ // than its parent.
+ if (acceptedParentById.size > 0) {
+ const rowById = new Map(issueRows.map((row) => [row.id, row] as const));
+ const orderedRows: typeof issueRows = [];
+ const emitted = new Set<string>();
+ for (const row of issueRows) {
+ const chain: typeof issueRows = [];
+ let current: (typeof issueRows)[number] | undefined = row;
+ while (current && !emitted.has(current.id)) {
+ emitted.add(current.id);
+ chain.push(current);
+ current = current.parentId ? rowById.get(current.parentId) : undefined;
+ }
+ for (const entry of chain.reverse()) orderedRows.push(entry);
+ }
+ issueRows.length = 0;
+ issueRows.push(...orderedRows);
+ }
+ }
+
// Flush the buffered rows in dependency order: issues first (parents of
// every other row), then comments (attachments may reference them), then
// the remaining children. Each writer inserts in chunked multi-row
diff --git a/server/src/services/import-write-types.ts b/server/src/services/import-write-types.ts
index 264f80f97a..f5d5744984 100644
--- a/server/src/services/import-write-types.ts
+++ b/server/src/services/import-write-types.ts
@@ -35,6 +35,18 @@ export interface ImportIssueRow {
/** Imported monitors land un-armed; only notes/provenance are restored. */
monitorNotes: string | null;
monitorScheduledBy: string | null;
+ /** Parent issue id resolved within the same import batch (pre-generated), or absent for roots. */
+ parentId?: string | null;
+ /**
+ * Preserved source timestamps carried by schemaVersion >= 7 bundles.
+ * Absent/null createdAt and updatedAt fall back to the insert time;
+ * absent startedAt stays null — the writer never fabricates it.
+ */
+ createdAt?: Date | null;
+ updatedAt?: Date | null;
+ startedAt?: Date | null;
+ completedAt?: Date | null;
+ cancelledAt?: Date | null;
}
/** A resolved comment row with a pre-generated id, ready for batch insert. */
diff --git a/server/src/services/issues.ts b/server/src/services/issues.ts
index 16dbd66207..b87156d913 100644
--- a/server/src/services/issues.ts
+++ b/server/src/services/issues.ts
@@ -94,7 +94,7 @@ import { resolveIssueGoalId, resolveNextIssueGoalId } from "./issue-goal-fallbac
import { getRunLogStore } from "./run-log-store.js";
import { getDefaultCompanyGoal } from "./goals.js";
import { assertAssignableAgent } from "./agent-assignability.js";
-import { insertRowsInChunks } from "./batch-insert.js";
+import { DEFAULT_INSERT_CHUNK_ROWS, insertRowsInChunks } from "./batch-insert.js";
import type {
ImportIssueRow,
ImportIssueCommentRow,
@@ -7352,11 +7352,19 @@ export function issueService(db: Db) {
responsibleUserId: null,
requestDepth: clampIssueRequestDepth(undefined),
originKind: "manual",
+ // The caller resolves parentId against ids in this same batch, so a
+ // parent always lands in the same insert (rows arrive parents-first).
+ parentId: row.parentId ?? null,
+ // Preserved bundle timestamps win; without them createdAt/updatedAt
+ // fall back to the insert time (the old defaultNow() behavior).
+ createdAt: row.createdAt ?? new Date(),
+ updatedAt: row.updatedAt ?? new Date(),
// Imported in-progress work did not start at import time; fabricating
- // startedAt here trips duration-based sweeps (e.g. productivity review).
- startedAt: null,
- completedAt: row.status === "done" ? new Date() : null,
- cancelledAt: row.status === "cancelled" ? new Date() : null,
+ // startedAt here trips duration-based sweeps (e.g. productivity
+ // review). Only a bundle-carried startedAt is written.
+ startedAt: row.startedAt ?? null,
+ completedAt: row.completedAt ?? (row.status === "done" ? new Date() : null),
+ cancelledAt: row.cancelledAt ?? (row.status === "cancelled" ? new Date() : null),
monitorNotes: row.monitorNotes ?? null,
monitorScheduledBy: row.monitorScheduledBy ?? null,
});
@@ -7396,10 +7404,28 @@ export function issueService(db: Db) {
};
});
await insertRowsInChunks(tx, issueComments, commentRows);
- // Mirror addComment's recency bump, once per affected issue.
- const issueIds = [...new Set(rows.map((row) => row.issueId))];
- if (issueIds.length > 0) {
- await tx.update(issues).set({ updatedAt: new Date() }).where(inArray(issues.id, issueIds));
+ // Mirror addComment's recency bump, once per affected issue — but never
+ // backwards. An issue imported with a preserved updatedAt keeps it
+ // unless a newer imported comment outdates it; issues without preserved
+ // timestamps carry an insert-time updatedAt, so GREATEST reproduces the
+ // old "bump to now" behavior for them.
+ const bumpAtByIssueId = new Map<string, Date>();
+ for (const row of commentRows) {
+ const existing = bumpAtByIssueId.get(row.issueId);
+ if (!existing || row.createdAt > existing) bumpAtByIssueId.set(row.issueId, row.createdAt);
+ }
+ const bumpEntries = [...bumpAtByIssueId.entries()];
+ for (let start = 0; start < bumpEntries.length; start += DEFAULT_INSERT_CHUNK_ROWS) {
+ const chunk = bumpEntries.slice(start, start + DEFAULT_INSERT_CHUNK_ROWS);
+ await tx.execute(sql`
+ update ${issues}
+ set updated_at = greatest(${issues.updatedAt}, bumps.bump_at)
+ from (values ${sql.join(
+ chunk.map(([issueId, bumpAt]) => sql`(${issueId}::uuid, ${bumpAt.toISOString()}::timestamptz)`),
+ sql`, `,
+ )}) as bumps(issue_id, bump_at)
+ where ${issues.id} = bumps.issue_id
+ `);
}
});
},