@astrale-domains/issues 0.3.3 → 0.3.4

package/README.md

@@ -30,7 +30,7 @@ The public callable surface keeps observation Project-owned and mutations receiv
 ```text
 Project.create
 Project.list
-Project.update | addMember | removeMember | createIssue | createTag | archive
+Project.update | addMember | removeMember | createIssue | receiveReport | listReports | completeReport | createTag | archive
 Issue.update | transition | assign | setTags | setParent | addComment | archive
 Comment.edit | delete
 Tag.edit | delete
@@ -54,12 +54,43 @@ collaboration state without requesting authority over every possible concrete Id
 another Domain.
 Those private execution fields are not a second public model and never replace the Policy edges.
 
-There is no Domain `Command`, receipt, universal idempotency layer, activity log, or undo system.
-`Project.create` and `Project.list` are Actions; the seventeen multi-step receiver operations are
-explicit Workflows whose Query and Mutation effects use stable steps. Set-style changes converge
-naturally and stale
-concurrent writes reject through atomic Mutation preconditions. Creation retries have no Domain
-replay guarantee; generic invocation idempotency belongs to the platform when it exists.
+`Project.receiveReport` is the owner-only intake for trusted integrations such as Admin. Its owner
+supplies a verified `reporterId`, an opaque `requestId`, `title`, `body`, and optional structured
+`context`. The public Admin facade must derive the reporter from authentication; ordinary senders
+must not receive this privileged owner capability or Project membership.
+
+One atomic mutation allocates the number, creates the Issue and reporter/containment edges, retains
+the original report, and sets `reportPending`. A query precondition fences the exact
+Project/reporter/request triple. A retry with identical content returns the original `{ id, reference }`,
+even after triage edits or archival; changed content under the same key is rejected. Independent
+request IDs remain independent reports. Known counter/key contention is retried up to eight attempts;
+unknown outcomes propagate, so the sender must retain the original payload and key until confirmation.
+The inline Workflow runner is not the source of durability: the graph receipt and atomic preconditions are.
+
+Context describes current client observations, separate from mutable Issue text. Missing versions and
+instance coordinates remain unknown. Creating a report does not grant access to this or other Issues.
+The generic domain has no Admin dependency. Admin setup, instance resolution, and scheduling remain
+integration-owned.
+
+The Project owner processes reports through two methods:
+
+- `Project.listReports({ pending?, cursor? })` returns up to 32 original reports, their reporters,
+  receipt times, and an opaque continuation cursor. Continue with the same pending filter. Omitting
+  the filter also includes completed originals. This method does not drain the collection.
+- `Project.completeReport({ issueId, duplicateCandidateId? })` acknowledges processing, optionally
+  adding one same-Project `issue_duplicate_candidate` edge in the same transaction. It preserves
+  all existing candidate edges, original evidence, and human edits. The edge is a triage suggestion,
+  not a merge. Traversal requires participation in the Project containing both endpoints.
+
+Completion guards the observed candidate set and pending state. Known concurrent changes reject
+without partial writes; the scheduler should reread and retry. Replaying a completed report returns
+`changed: false`, without applying a new candidate. Only acknowledge after integration-owned effects
+are durably recorded; those effects must also be idempotent because a worker can stop between them
+and acknowledgement. A failed report remains pending. An integration must resume pagination rather
+than repeatedly processing only the first page, so a persistent failure cannot starve later reports.
+
+Other creation methods retain their existing retry semantics. Set-style changes converge naturally;
+stale concurrent edits reject through atomic mutation preconditions.
 
 The mounted View defaults to a focused open-Issue Inbox with queue progress and keyboard or button
 navigation. Accepted work has a dedicated discussion view, while Browse searches and filters the

package/dist/schema/index.d.ts

@@ -1,6 +1,7 @@
 export { schema } from './schema.js';
 export type { IssuesDomain, IssuesSchema } from './schema.js';
 export { Project, project_has_member, project_owned_by } from './modules/project/index.js';
-export { Issue, issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
+export { Issue, issue_assigned_to, issue_duplicate_candidate, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
 export { Comment, comment_authored_by, issue_has_comment } from './modules/comment/index.js';
 export { Tag, issue_tagged_with, project_contains_tag } from './modules/tag/index.js';
+export { reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, type ReportContent, } from './modules/issue/index.js';

package/dist/schema/index.js

@@ -1,5 +1,6 @@
 export { schema } from './schema.js';
 export { Project, project_has_member, project_owned_by } from './modules/project/index.js';
-export { Issue, issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
+export { Issue, issue_assigned_to, issue_duplicate_candidate, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
 export { Comment, comment_authored_by, issue_has_comment } from './modules/comment/index.js';
 export { Tag, issue_tagged_with, project_contains_tag } from './modules/tag/index.js';
+export { reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, } from './modules/issue/index.js';

package/dist/schema/modules/comment/classes/comment.d.ts

@@ -5,7 +5,7 @@ export declare const Comment: import("@astrale-os/sdk/schema").AuthoredNodeClass
     readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
     readonly properties: {
         body: z.ZodString;
-        authorId: import("@astrale-os/sdk/schema").Property<z.ZodString, {}, never>;
+        authorId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {}>;
     };
     readonly methods: {
         edit: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{

package/dist/schema/modules/issue/classes/index.d.ts

@@ -3,3 +3,4 @@ export { issue_reported_by } from './issue-reported-by.js';
 export { issue_subtask_of } from './issue-subtask-of.js';
 export { Issue } from './issue.js';
 export { project_contains_issue } from './project-contains-issue.js';
+export { issue_duplicate_candidate } from './issue-duplicate-candidate.js';

package/dist/schema/modules/issue/classes/index.js

@@ -3,3 +3,4 @@ export { issue_reported_by } from './issue-reported-by.js';
 export { issue_subtask_of } from './issue-subtask-of.js';
 export { Issue } from './issue.js';
 export { project_contains_issue } from './project-contains-issue.js';
+export { issue_duplicate_candidate } from './issue-duplicate-candidate.js';

package/dist/schema/modules/issue/classes/issue-duplicate-candidate.d.ts

@@ -0,0 +1,18 @@
+export declare const issue_duplicate_candidate: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+    readonly depth: 0;
+    readonly abstract: false;
+    readonly extends: readonly [];
+    readonly properties: never;
+    readonly source: {
+        readonly as: "report";
+        readonly outgoing: "0..*";
+    };
+    readonly target: {
+        readonly as: "candidate";
+        readonly incoming: "0..*";
+    };
+    readonly constraints: {
+        readonly noSelf: true;
+    };
+    readonly effectiveProperties: never;
+}>;

package/dist/schema/modules/issue/classes/issue-duplicate-candidate.js

@@ -0,0 +1,10 @@
+import { edgeClass } from '@astrale-os/sdk/schema';
+import { TraverseDuplicateCandidate } from '../policies/traverse-duplicate-candidate.js';
+import { Issue } from './issue.js';
+export const issue_duplicate_candidate = edgeClass.directed({
+    description: 'A retained report may describe the same problem as another Issue; a suggestion for triage, not a merge or canonical identity.',
+    source: { as: 'report', accepts: [() => Issue], outgoing: '0..*' },
+    target: { as: 'candidate', accepts: [() => Issue], incoming: '0..*' },
+    constraints: { noSelf: true },
+    policies: { traverse: () => TraverseDuplicateCandidate },
+});

package/dist/schema/modules/issue/classes/issue.d.ts

@@ -5,8 +5,8 @@ export declare const Issue: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
     readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
     readonly properties: {
         reference: z.ZodString;
-        reporterId: import("@astrale-os/sdk/schema").Property<z.ZodString, {}, never>;
-        assigneeId: import("@astrale-os/sdk/schema").Property<z.ZodOptional<z.ZodString>, {}, never>;
+        reporterId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {}>;
+        assigneeId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodOptional<z.ZodString>, {}>;
         status: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
             readonly open: {
                 readonly accept: "accepted";
@@ -36,6 +36,45 @@ export declare const Issue: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
         }>;
         priority: z.ZodNumber;
         archived: z.ZodBoolean;
+        reportRequestId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodOptional<z.ZodString>, {}>;
+        report: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodOptional<z.ZodObject<{
+            title: z.ZodString;
+            body: z.ZodString;
+            context: z.ZodOptional<z.ZodObject<{
+                observedAt: z.ZodString;
+                cli: z.ZodObject<{
+                    version: z.ZodString;
+                    platform: z.ZodString;
+                    arch: z.ZodString;
+                }, z.core.$strict>;
+                runtime: z.ZodObject<{
+                    node: z.ZodString;
+                    bun: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                project: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodOptional<z.ZodString>;
+                    packages: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        declared: z.ZodOptional<z.ZodString>;
+                        version: z.ZodOptional<z.ZodString>;
+                        source: z.ZodEnum<{
+                            installed: "installed";
+                            local: "local";
+                            unresolved: "unresolved";
+                        }>;
+                        commit: z.ZodOptional<z.ZodString>;
+                        dirty: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                instance: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    issuer: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>, {}>;
+        reportPending: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodOptional<z.ZodBoolean>, {}>;
     };
     readonly methods: {
         update: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{

package/dist/schema/modules/issue/classes/issue.js

@@ -11,6 +11,7 @@ import { transitionIssueMethod } from '../functions/transition-issue.js';
 import { updateIssueMethod } from '../functions/update-issue.js';
 import { ContributeToIssue } from '../policies/contribute-to-issue.js';
 import { issueStatus } from '../states/index.js';
+import { reportContentValue } from '../types/report.js';
 export const Issue = nodeClass({
     description: 'One immutable-reference work item contained by exactly one Project.',
     icon: classIcon.lucide(CircleDot),
@@ -22,6 +23,9 @@ export const Issue = nodeClass({
         status: stateProperty(issueStatus),
         priority: z.number().int().min(0).max(4),
         archived: z.boolean(),
+        reportRequestId: property(z.string().min(1).max(128).optional(), {}),
+        report: property(reportContentValue.optional(), {}),
+        reportPending: property(z.boolean().optional(), {}),
     },
     methods: {
         update: updateIssueMethod,

package/dist/schema/modules/issue/index.d.ts

@@ -1,5 +1,5 @@
-export { issueValue } from './types/index.js';
+export { issueValue, reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, type ReportContent, } from './types/index.js';
 export { issueStatus, type IssueEvent, type IssueStatus } from './states/index.js';
-export { issue_assigned_to, issue_reported_by, issue_subtask_of, Issue, project_contains_issue, } from './classes/index.js';
+export { issue_assigned_to, issue_duplicate_candidate, issue_reported_by, issue_subtask_of, Issue, project_contains_issue, } from './classes/index.js';
 export { addIssueCommentMethod, archiveIssueMethod, assignIssueMethod, setIssueParentMethod, setIssueTagsMethod, transitionIssueMethod, updateIssueMethod, } from './functions/index.js';
-export { ContributeToIssue, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, } from './policies/index.js';
+export { ContributeToIssue, TraverseDuplicateCandidate, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, } from './policies/index.js';

package/dist/schema/modules/issue/index.js

@@ -1,5 +1,5 @@
-export { issueValue } from './types/index.js';
+export { issueValue, reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, } from './types/index.js';
 export { issueStatus } from './states/index.js';
-export { issue_assigned_to, issue_reported_by, issue_subtask_of, Issue, project_contains_issue, } from './classes/index.js';
+export { issue_assigned_to, issue_duplicate_candidate, issue_reported_by, issue_subtask_of, Issue, project_contains_issue, } from './classes/index.js';
 export { addIssueCommentMethod, archiveIssueMethod, assignIssueMethod, setIssueParentMethod, setIssueTagsMethod, transitionIssueMethod, updateIssueMethod, } from './functions/index.js';
-export { ContributeToIssue, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, } from './policies/index.js';
+export { ContributeToIssue, TraverseDuplicateCandidate, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, } from './policies/index.js';

package/dist/schema/modules/issue/policies/index.d.ts

@@ -3,3 +3,4 @@ export { TraverseIssueAssignee } from './traverse-issue-assignee.js';
 export { TraverseIssueParent } from './traverse-issue-parent.js';
 export { TraverseIssueReporter } from './traverse-issue-reporter.js';
 export { TraverseProjectIssue } from './traverse-project-issue.js';
+export { TraverseDuplicateCandidate } from './traverse-duplicate-candidate.js';

package/dist/schema/modules/issue/policies/index.js

@@ -3,3 +3,4 @@ export { TraverseIssueAssignee } from './traverse-issue-assignee.js';
 export { TraverseIssueParent } from './traverse-issue-parent.js';
 export { TraverseIssueReporter } from './traverse-issue-reporter.js';
 export { TraverseProjectIssue } from './traverse-project-issue.js';
+export { TraverseDuplicateCandidate } from './traverse-duplicate-candidate.js';

package/dist/schema/modules/issue/policies/traverse-duplicate-candidate.d.ts

@@ -0,0 +1 @@
+export declare const TraverseDuplicateCandidate: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/modules/issue/policies/traverse-duplicate-candidate.js

@@ -0,0 +1,10 @@
+import { policy } from '@astrale-os/sdk/schema';
+import { Project, project_has_member, project_owned_by } from '../../project/index.js';
+import { project_contains_issue } from '../classes/project-contains-issue.js';
+export const TraverseDuplicateCandidate = policy({
+    description: 'The caller participates in the Project containing both candidate duplicate Issues.',
+    match: ({ allOf, anyOf, edge, exists, source, target, subject }) => exists(({ node }) => {
+        const project = node(() => Project);
+        return allOf(edge({ source: project, class: () => project_contains_issue, target: source }), edge({ source: project, class: () => project_contains_issue, target }), anyOf(edge({ source: subject, class: () => project_owned_by, target: project }), edge({ source: subject, class: () => project_has_member, target: project })));
+    }),
+});

package/dist/schema/modules/issue/types/index.d.ts

@@ -1 +1,2 @@
 export { issueValue } from './issue.js';
+export { reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, type ReportContent, } from './report.js';

package/dist/schema/modules/issue/types/index.js

@@ -1 +1,2 @@
 export { issueValue } from './issue.js';
+export { reportContentValue, reportContextValue, receiveReportInput, reportReceiptValue, reportRecordValue, reportPageValue, } from './report.js';

package/dist/schema/modules/issue/types/report.d.ts

@@ -0,0 +1,207 @@
+import { z } from 'zod';
+/** Observations at submission time; never evidence of a historical deployed build. */
+export declare const reportContextValue: z.ZodObject<{
+    observedAt: z.ZodString;
+    cli: z.ZodObject<{
+        version: z.ZodString;
+        platform: z.ZodString;
+        arch: z.ZodString;
+    }, z.core.$strict>;
+    runtime: z.ZodObject<{
+        node: z.ZodString;
+        bun: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    project: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        packages: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            declared: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+            source: z.ZodEnum<{
+                installed: "installed";
+                local: "local";
+                unresolved: "unresolved";
+            }>;
+            commit: z.ZodOptional<z.ZodString>;
+            dirty: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    instance: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        issuer: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const reportContentValue: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    context: z.ZodOptional<z.ZodObject<{
+        observedAt: z.ZodString;
+        cli: z.ZodObject<{
+            version: z.ZodString;
+            platform: z.ZodString;
+            arch: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            node: z.ZodString;
+            bun: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        project: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            packages: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                declared: z.ZodOptional<z.ZodString>;
+                version: z.ZodOptional<z.ZodString>;
+                source: z.ZodEnum<{
+                    installed: "installed";
+                    local: "local";
+                    unresolved: "unresolved";
+                }>;
+                commit: z.ZodOptional<z.ZodString>;
+                dirty: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        instance: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            issuer: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const receiveReportInput: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    context: z.ZodOptional<z.ZodObject<{
+        observedAt: z.ZodString;
+        cli: z.ZodObject<{
+            version: z.ZodString;
+            platform: z.ZodString;
+            arch: z.ZodString;
+        }, z.core.$strict>;
+        runtime: z.ZodObject<{
+            node: z.ZodString;
+            bun: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        project: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            packages: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                declared: z.ZodOptional<z.ZodString>;
+                version: z.ZodOptional<z.ZodString>;
+                source: z.ZodEnum<{
+                    installed: "installed";
+                    local: "local";
+                    unresolved: "unresolved";
+                }>;
+                commit: z.ZodOptional<z.ZodString>;
+                dirty: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        instance: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            issuer: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    requestId: z.ZodString;
+    reporterId: z.ZodString;
+}, z.core.$strict>;
+export declare const reportReceiptValue: z.ZodObject<{
+    id: z.ZodString;
+    reference: z.ZodString;
+}, z.core.$strict>;
+export type ReportContent = z.infer<typeof reportContentValue>;
+export declare const reportRecordValue: z.ZodObject<{
+    id: z.ZodString;
+    reference: z.ZodString;
+    reporterId: z.ZodString;
+    content: z.ZodObject<{
+        title: z.ZodString;
+        body: z.ZodString;
+        context: z.ZodOptional<z.ZodObject<{
+            observedAt: z.ZodString;
+            cli: z.ZodObject<{
+                version: z.ZodString;
+                platform: z.ZodString;
+                arch: z.ZodString;
+            }, z.core.$strict>;
+            runtime: z.ZodObject<{
+                node: z.ZodString;
+                bun: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            project: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+                packages: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    declared: z.ZodOptional<z.ZodString>;
+                    version: z.ZodOptional<z.ZodString>;
+                    source: z.ZodEnum<{
+                        installed: "installed";
+                        local: "local";
+                        unresolved: "unresolved";
+                    }>;
+                    commit: z.ZodOptional<z.ZodString>;
+                    dirty: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            instance: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                issuer: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    pending: z.ZodBoolean;
+    receivedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const reportPageValue: z.ZodObject<{
+    reports: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        reference: z.ZodString;
+        reporterId: z.ZodString;
+        content: z.ZodObject<{
+            title: z.ZodString;
+            body: z.ZodString;
+            context: z.ZodOptional<z.ZodObject<{
+                observedAt: z.ZodString;
+                cli: z.ZodObject<{
+                    version: z.ZodString;
+                    platform: z.ZodString;
+                    arch: z.ZodString;
+                }, z.core.$strict>;
+                runtime: z.ZodObject<{
+                    node: z.ZodString;
+                    bun: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                project: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodOptional<z.ZodString>;
+                    packages: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        declared: z.ZodOptional<z.ZodString>;
+                        version: z.ZodOptional<z.ZodString>;
+                        source: z.ZodEnum<{
+                            installed: "installed";
+                            local: "local";
+                            unresolved: "unresolved";
+                        }>;
+                        commit: z.ZodOptional<z.ZodString>;
+                        dirty: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                instance: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    issuer: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        pending: z.ZodBoolean;
+        receivedAt: z.ZodString;
+    }, z.core.$strict>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;

package/dist/schema/modules/issue/types/report.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+const coordinate = z.string().min(1).max(2_048);
+const version = z.string().max(128);
+/** Observations at submission time; never evidence of a historical deployed build. */
+export const reportContextValue = z.strictObject({
+    observedAt: z.string().min(1).max(64),
+    cli: z.strictObject({ version, platform: z.string().max(64), arch: z.string().max(64) }),
+    runtime: z.strictObject({ node: version, bun: version.optional() }),
+    project: z
+        .strictObject({
+        name: z.string().max(200),
+        version: version.optional(),
+        packages: z
+            .array(z.strictObject({
+            name: z.string().min(1).max(200),
+            declared: z.string().max(128).optional(),
+            version: version.optional(),
+            source: z.enum(['installed', 'local', 'unresolved']),
+            commit: z.string().min(40).max(64).optional(),
+            dirty: z.boolean().optional(),
+        }))
+            .max(64),
+    })
+        .optional(),
+    instance: z
+        .strictObject({
+        name: z.string().max(200),
+        issuer: coordinate.optional(),
+        url: coordinate.optional(),
+    })
+        .optional(),
+});
+export const reportContentValue = z.strictObject({
+    title: z.string().min(1).max(200),
+    body: z.string().min(1).max(50_000),
+    context: reportContextValue.optional(),
+});
+export const receiveReportInput = reportContentValue.extend({
+    requestId: z.string().min(1).max(128),
+    reporterId: nodeIdValue,
+});
+export const reportReceiptValue = z.strictObject({
+    id: nodeIdValue,
+    reference: z.string().min(1).max(32),
+});
+export const reportRecordValue = reportReceiptValue.extend({
+    reporterId: nodeIdValue,
+    content: reportContentValue,
+    pending: z.boolean(),
+    receivedAt: z.string().min(1).max(64),
+});
+export const reportPageValue = z.strictObject({
+    reports: z.array(reportRecordValue).max(32),
+    cursor: z.string().optional(),
+});

package/dist/schema/modules/project/classes/project.d.ts

@@ -5,9 +5,9 @@ export declare const Project: import("@astrale-os/sdk/schema").AuthoredNodeClass
     readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
     readonly properties: {
         key: z.ZodString;
-        ownerId: import("@astrale-os/sdk/schema").Property<z.ZodString, {}, never>;
-        memberIds: import("@astrale-os/sdk/schema").Property<z.ZodArray<z.ZodString>, {}, never>;
-        nextIssueNumber: import("@astrale-os/sdk/schema").Property<z.ZodNumber, {}, never>;
+        ownerId: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {}>;
+        memberIds: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodArray<z.ZodString>, {}>;
+        nextIssueNumber: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodNumber, {}>;
         archived: z.ZodBoolean;
     };
     readonly methods: {
@@ -99,6 +99,106 @@ export declare const Project: import("@astrale-os/sdk/schema").AuthoredNodeClass
                 archived: boolean;
             };
         }, "authorized", false, false>>;
+        receiveReport: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            title: string;
+            body: string;
+            context?: {
+                observedAt: string;
+                cli: {
+                    version: string;
+                    platform: string;
+                    arch: string;
+                };
+                runtime: {
+                    node: string;
+                    bun?: string | undefined;
+                };
+                project?: {
+                    name: string;
+                    version?: string | undefined;
+                    packages: {
+                        name: string;
+                        declared?: string | undefined;
+                        version?: string | undefined;
+                        source: "installed" | "local" | "unresolved";
+                        commit?: string | undefined;
+                        dirty?: boolean | undefined;
+                    }[];
+                } | undefined;
+                instance?: {
+                    name: string;
+                    issuer?: string | undefined;
+                    url?: string | undefined;
+                } | undefined;
+            } | undefined;
+            requestId: string;
+            reporterId: string;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                id: string;
+                reference: string;
+            };
+        }, "authorized", false, false>>;
+        listReports: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            pending?: boolean | undefined;
+            cursor?: string | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                reports: {
+                    id: string;
+                    reference: string;
+                    reporterId: string;
+                    content: {
+                        title: string;
+                        body: string;
+                        context?: {
+                            observedAt: string;
+                            cli: {
+                                version: string;
+                                platform: string;
+                                arch: string;
+                            };
+                            runtime: {
+                                node: string;
+                                bun?: string | undefined;
+                            };
+                            project?: {
+                                name: string;
+                                version?: string | undefined;
+                                packages: {
+                                    name: string;
+                                    declared?: string | undefined;
+                                    version?: string | undefined;
+                                    source: "installed" | "local" | "unresolved";
+                                    commit?: string | undefined;
+                                    dirty?: boolean | undefined;
+                                }[];
+                            } | undefined;
+                            instance?: {
+                                name: string;
+                                issuer?: string | undefined;
+                                url?: string | undefined;
+                            } | undefined;
+                        } | undefined;
+                    };
+                    pending: boolean;
+                    receivedAt: string;
+                }[];
+                cursor?: string | undefined;
+            };
+        }, "authorized", false, false>>;
+        completeReport: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+            issueId: string;
+            duplicateCandidateId?: string | undefined;
+        }, {
+            readonly mode: 'value';
+            readonly value: {
+                issueId: string;
+                changed: boolean;
+            };
+        }, "authorized", false, false>>;
         createTag: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
             name: string;
             color?: string | undefined;

package/dist/schema/modules/project/classes/project.js

@@ -4,10 +4,13 @@ import { z } from 'zod';
 import { nodeIdValue } from '../../../types/index.js';
 import { addProjectMemberMethod } from '../functions/add-project-member.js';
 import { archiveProjectMethod } from '../functions/archive-project.js';
+import { completeProjectReportMethod } from '../functions/complete-project-report.js';
 import { createProjectIssueMethod } from '../functions/create-project-issue.js';
 import { createProjectTagMethod } from '../functions/create-project-tag.js';
 import { createProjectMethod } from '../functions/create-project.js';
+import { listProjectReportsMethod } from '../functions/list-project-reports.js';
 import { listProjectsMethod } from '../functions/list-projects.js';
+import { receiveProjectReportMethod } from '../functions/receive-project-report.js';
 import { removeProjectMemberMethod } from '../functions/remove-project-member.js';
 import { updateProjectMethod } from '../functions/update-project.js';
 import { ContributeToProject } from '../policies/contribute-to-project.js';
@@ -29,6 +32,9 @@ export const Project = nodeClass({
         addMember: addProjectMemberMethod,
         removeMember: removeProjectMemberMethod,
         createIssue: createProjectIssueMethod,
+        receiveReport: receiveProjectReportMethod,
+        listReports: listProjectReportsMethod,
+        completeReport: completeProjectReportMethod,
         createTag: createProjectTagMethod,
         archive: archiveProjectMethod,
     },

package/dist/schema/modules/project/functions/complete-project-report.d.ts

@@ -0,0 +1,10 @@
+export declare const completeProjectReportMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    issueId: string;
+    duplicateCandidateId?: string | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        issueId: string;
+        changed: boolean;
+    };
+}, "authorized", false, false>>;

package/dist/schema/modules/project/functions/complete-project-report.js

@@ -0,0 +1,11 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { nodeIdValue } from '../../../types/index.js';
+import { ManageProject } from '../policies/manage-project.js';
+export const completeProjectReportMethod = method({
+    description: 'Confirm report processing once, optionally adding one duplicate candidate without editing original evidence or human triage.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({ issueId: nodeIdValue, duplicateCandidateId: nodeIdValue.optional() }),
+    output: z.strictObject({ issueId: nodeIdValue, changed: z.boolean() }),
+});

package/dist/schema/modules/project/functions/index.d.ts

@@ -6,3 +6,6 @@ export { createProjectMethod } from './create-project.js';
 export { listProjectsMethod } from './list-projects.js';
 export { removeProjectMemberMethod } from './remove-project-member.js';
 export { updateProjectMethod } from './update-project.js';
+export { receiveProjectReportMethod } from './receive-project-report.js';
+export { listProjectReportsMethod } from './list-project-reports.js';
+export { completeProjectReportMethod } from './complete-project-report.js';

package/dist/schema/modules/project/functions/index.js

@@ -6,3 +6,6 @@ export { createProjectMethod } from './create-project.js';
 export { listProjectsMethod } from './list-projects.js';
 export { removeProjectMemberMethod } from './remove-project-member.js';
 export { updateProjectMethod } from './update-project.js';
+export { receiveProjectReportMethod } from './receive-project-report.js';
+export { listProjectReportsMethod } from './list-project-reports.js';
+export { completeProjectReportMethod } from './complete-project-report.js';

package/dist/schema/modules/project/functions/list-project-reports.d.ts

@@ -0,0 +1,49 @@
+export declare const listProjectReportsMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    pending?: boolean | undefined;
+    cursor?: string | undefined;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        reports: {
+            id: string;
+            reference: string;
+            reporterId: string;
+            content: {
+                title: string;
+                body: string;
+                context?: {
+                    observedAt: string;
+                    cli: {
+                        version: string;
+                        platform: string;
+                        arch: string;
+                    };
+                    runtime: {
+                        node: string;
+                        bun?: string | undefined;
+                    };
+                    project?: {
+                        name: string;
+                        version?: string | undefined;
+                        packages: {
+                            name: string;
+                            declared?: string | undefined;
+                            version?: string | undefined;
+                            source: "installed" | "local" | "unresolved";
+                            commit?: string | undefined;
+                            dirty?: boolean | undefined;
+                        }[];
+                    } | undefined;
+                    instance?: {
+                        name: string;
+                        issuer?: string | undefined;
+                        url?: string | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+            pending: boolean;
+            receivedAt: string;
+        }[];
+        cursor?: string | undefined;
+    };
+}, "authorized", false, false>>;

package/dist/schema/modules/project/functions/list-project-reports.js

@@ -0,0 +1,14 @@
+import { method } from '@astrale-os/sdk/schema';
+import { z } from 'zod';
+import { reportPageValue } from '../../issue/index.js';
+import { ManageProject } from '../policies/manage-project.js';
+export const listProjectReportsMethod = method({
+    description: 'Read one bounded page of original reports for this Project owner; resume the returned cursor with the same pending filter.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: z.strictObject({
+        pending: z.boolean().optional(),
+        cursor: z.string().max(16_384).optional(),
+    }),
+    output: reportPageValue,
+});

package/dist/schema/modules/project/functions/receive-project-report.d.ts

@@ -0,0 +1,41 @@
+export declare const receiveProjectReportMethod: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+    title: string;
+    body: string;
+    context?: {
+        observedAt: string;
+        cli: {
+            version: string;
+            platform: string;
+            arch: string;
+        };
+        runtime: {
+            node: string;
+            bun?: string | undefined;
+        };
+        project?: {
+            name: string;
+            version?: string | undefined;
+            packages: {
+                name: string;
+                declared?: string | undefined;
+                version?: string | undefined;
+                source: "installed" | "local" | "unresolved";
+                commit?: string | undefined;
+                dirty?: boolean | undefined;
+            }[];
+        } | undefined;
+        instance?: {
+            name: string;
+            issuer?: string | undefined;
+            url?: string | undefined;
+        } | undefined;
+    } | undefined;
+    requestId: string;
+    reporterId: string;
+}, {
+    readonly mode: 'value';
+    readonly value: {
+        id: string;
+        reference: string;
+    };
+}, "authorized", false, false>>;

package/dist/schema/modules/project/functions/receive-project-report.js

@@ -0,0 +1,10 @@
+import { method } from '@astrale-os/sdk/schema';
+import { receiveReportInput, reportReceiptValue } from '../../issue/index.js';
+import { ManageProject } from '../policies/manage-project.js';
+export const receiveProjectReportMethod = method({
+    description: 'Receive an idempotent report from a trusted Project owner integration, attributing its verified reporter without granting Project membership.',
+    auth: 'authorized',
+    policy: ({ check, self }) => check(ManageProject, self),
+    input: receiveReportInput,
+    output: reportReceiptValue,
+});

package/dist/schema/modules/tag/classes/tag.d.ts

@@ -5,9 +5,9 @@ export declare const Tag: import("@astrale-os/sdk/schema").AuthoredNodeClass<{
     readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
     readonly properties: {
         slug: z.ZodString;
-        color: import("@astrale-os/sdk/schema").Property<z.ZodString, {
+        color: import("@astrale-os/sdk/schema").AuthoredProperty<z.ZodString, {
             readonly required: false;
-        }, never>;
+        }>;
     };
     readonly methods: {
         edit: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{

package/dist/schema/schema.d.ts

@@ -8,9 +8,9 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
             readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
             readonly properties: {
                 key: import("zod").ZodString;
-                ownerId: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {}, never>;
-                memberIds: import("@astrale-os/sdk/schema").Property<import("zod").ZodArray<import("zod").ZodString>, {}, never>;
-                nextIssueNumber: import("@astrale-os/sdk/schema").Property<import("zod").ZodNumber, {}, never>;
+                ownerId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {}>;
+                memberIds: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodArray<import("zod").ZodString>, {}>;
+                nextIssueNumber: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodNumber, {}>;
                 archived: import("zod").ZodBoolean;
             };
             readonly methods: {
@@ -102,6 +102,106 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
                         archived: boolean;
                     };
                 }, "authorized", false, false>>;
+                receiveReport: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    title: string;
+                    body: string;
+                    context?: {
+                        observedAt: string;
+                        cli: {
+                            version: string;
+                            platform: string;
+                            arch: string;
+                        };
+                        runtime: {
+                            node: string;
+                            bun?: string | undefined;
+                        };
+                        project?: {
+                            name: string;
+                            version?: string | undefined;
+                            packages: {
+                                name: string;
+                                declared?: string | undefined;
+                                version?: string | undefined;
+                                source: "installed" | "local" | "unresolved";
+                                commit?: string | undefined;
+                                dirty?: boolean | undefined;
+                            }[];
+                        } | undefined;
+                        instance?: {
+                            name: string;
+                            issuer?: string | undefined;
+                            url?: string | undefined;
+                        } | undefined;
+                    } | undefined;
+                    requestId: string;
+                    reporterId: string;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        id: string;
+                        reference: string;
+                    };
+                }, "authorized", false, false>>;
+                listReports: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    pending?: boolean | undefined;
+                    cursor?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        reports: {
+                            id: string;
+                            reference: string;
+                            reporterId: string;
+                            content: {
+                                title: string;
+                                body: string;
+                                context?: {
+                                    observedAt: string;
+                                    cli: {
+                                        version: string;
+                                        platform: string;
+                                        arch: string;
+                                    };
+                                    runtime: {
+                                        node: string;
+                                        bun?: string | undefined;
+                                    };
+                                    project?: {
+                                        name: string;
+                                        version?: string | undefined;
+                                        packages: {
+                                            name: string;
+                                            declared?: string | undefined;
+                                            version?: string | undefined;
+                                            source: "installed" | "local" | "unresolved";
+                                            commit?: string | undefined;
+                                            dirty?: boolean | undefined;
+                                        }[];
+                                    } | undefined;
+                                    instance?: {
+                                        name: string;
+                                        issuer?: string | undefined;
+                                        url?: string | undefined;
+                                    } | undefined;
+                                } | undefined;
+                            };
+                            pending: boolean;
+                            receivedAt: string;
+                        }[];
+                        cursor?: string | undefined;
+                    };
+                }, "authorized", false, false>>;
+                completeReport: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
+                    issueId: string;
+                    duplicateCandidateId?: string | undefined;
+                }, {
+                    readonly mode: 'value';
+                    readonly value: {
+                        issueId: string;
+                        changed: boolean;
+                    };
+                }, "authorized", false, false>>;
                 createTag: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
                     name: string;
                     color?: string | undefined;
@@ -132,8 +232,8 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
             readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Descriptable">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
             readonly properties: {
                 reference: import("zod").ZodString;
-                reporterId: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {}, never>;
-                assigneeId: import("@astrale-os/sdk/schema").Property<import("zod").ZodOptional<import("zod").ZodString>, {}, never>;
+                reporterId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {}>;
+                assigneeId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodOptional<import("zod").ZodString>, {}>;
                 status: import("@astrale-os/sdk/schema").StateProperty<import("@astrale-os/sdk/schema").StateMachine<{
                     readonly open: {
                         readonly accept: "accepted";
@@ -163,6 +263,45 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
                 }>;
                 priority: import("zod").ZodNumber;
                 archived: import("zod").ZodBoolean;
+                reportRequestId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodOptional<import("zod").ZodString>, {}>;
+                report: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodOptional<import("zod").ZodObject<{
+                    title: import("zod").ZodString;
+                    body: import("zod").ZodString;
+                    context: import("zod").ZodOptional<import("zod").ZodObject<{
+                        observedAt: import("zod").ZodString;
+                        cli: import("zod").ZodObject<{
+                            version: import("zod").ZodString;
+                            platform: import("zod").ZodString;
+                            arch: import("zod").ZodString;
+                        }, import("zod/v4/core").$strict>;
+                        runtime: import("zod").ZodObject<{
+                            node: import("zod").ZodString;
+                            bun: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strict>;
+                        project: import("zod").ZodOptional<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            version: import("zod").ZodOptional<import("zod").ZodString>;
+                            packages: import("zod").ZodArray<import("zod").ZodObject<{
+                                name: import("zod").ZodString;
+                                declared: import("zod").ZodOptional<import("zod").ZodString>;
+                                version: import("zod").ZodOptional<import("zod").ZodString>;
+                                source: import("zod").ZodEnum<{
+                                    installed: "installed";
+                                    local: "local";
+                                    unresolved: "unresolved";
+                                }>;
+                                commit: import("zod").ZodOptional<import("zod").ZodString>;
+                                dirty: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                            }, import("zod/v4/core").$strict>>;
+                        }, import("zod/v4/core").$strict>>;
+                        instance: import("zod").ZodOptional<import("zod").ZodObject<{
+                            name: import("zod").ZodString;
+                            issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                            url: import("zod").ZodOptional<import("zod").ZodString>;
+                        }, import("zod/v4/core").$strict>>;
+                    }, import("zod/v4/core").$strict>>;
+                }, import("zod/v4/core").$strict>>, {}>;
+                reportPending: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodOptional<import("zod").ZodBoolean>, {}>;
             };
             readonly methods: {
                 update: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -257,7 +396,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
             readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
             readonly properties: {
                 body: import("zod").ZodString;
-                authorId: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {}, never>;
+                authorId: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {}>;
             };
             readonly methods: {
                 edit: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -287,9 +426,9 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
             readonly extends: readonly [import("@astrale-os/sdk/schema").KernelClass<"Named">, import("@astrale-os/sdk/schema").KernelClass<"Timestamped">];
             readonly properties: {
                 slug: import("zod").ZodString;
-                color: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {
+                color: import("@astrale-os/sdk/schema").AuthoredProperty<import("zod").ZodString, {
                     readonly required: false;
-                }, never>;
+                }>;
             };
             readonly methods: {
                 edit: import("@astrale-os/sdk/schema").Method<import("@astrale-os/sdk/schema").CallableProjection<{
@@ -415,6 +554,24 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
             };
             readonly effectiveProperties: never;
         }>;
+        readonly issue_duplicate_candidate: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
+            readonly depth: 0;
+            readonly abstract: false;
+            readonly extends: readonly [];
+            readonly properties: never;
+            readonly source: {
+                readonly as: "report";
+                readonly outgoing: "0..*";
+            };
+            readonly target: {
+                readonly as: "candidate";
+                readonly incoming: "0..*";
+            };
+            readonly constraints: {
+                readonly noSelf: true;
+            };
+            readonly effectiveProperties: never;
+        }>;
         readonly issue_has_comment: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
             readonly depth: 0;
             readonly abstract: false;
@@ -483,6 +640,7 @@ export declare const schema: import("@astrale-os/sdk/schema").AuthoredSchema<"is
     readonly policies: {
         readonly ManageProject: import("@astrale-os/sdk/schema").Policy;
         readonly ContributeToProject: import("@astrale-os/sdk/schema").Policy;
+        readonly TraverseDuplicateCandidate: import("@astrale-os/sdk/schema").Policy;
         readonly ContributeToIssue: import("@astrale-os/sdk/schema").Policy;
         readonly ContributeToTag: import("@astrale-os/sdk/schema").Policy;
         readonly ManageTag: import("@astrale-os/sdk/schema").Policy;

package/dist/schema/schema.js

@@ -1,6 +1,6 @@
 import { KernelSchema, defineSchema, view } from '@astrale-os/sdk/schema';
 import { Comment, comment_authored_by, issue_has_comment, ContributeToComment, EditOwnComment, TraverseCommentRelationship, TraverseIssueComment, } from './modules/comment/index.js';
-import { Issue, ContributeToIssue, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
+import { Issue, issue_duplicate_candidate, TraverseDuplicateCandidate, ContributeToIssue, TraverseIssueAssignee, TraverseIssueParent, TraverseIssueReporter, TraverseProjectIssue, issue_assigned_to, issue_reported_by, issue_subtask_of, project_contains_issue, } from './modules/issue/index.js';
 import { Project, ContributeToProject, ManageProject, TraverseProjectMember, TraverseProjectOwner, project_has_member, project_owned_by, } from './modules/project/index.js';
 import { Tag, ContributeToTag, ManageTag, TraverseIssueTag, TraverseProjectTag, issue_tagged_with, project_contains_tag, } from './modules/tag/index.js';
 const origin = 'issues.astrale.ai';
@@ -15,6 +15,7 @@ const classes = {
     issue_reported_by,
     issue_assigned_to,
     issue_subtask_of,
+    issue_duplicate_candidate,
     issue_has_comment,
     comment_authored_by,
     project_contains_tag,
@@ -23,6 +24,7 @@ const classes = {
 const policies = {
     ManageProject,
     ContributeToProject,
+    TraverseDuplicateCandidate,
     ContributeToIssue,
     ContributeToTag,
     ManageTag,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-domains/issues",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/astrale-os/domains.git",
@@ -28,15 +28,15 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@astrale-os/sdk": "0.5.0-beta.131",
+    "@astrale-os/sdk": "0.6.0-beta.0",
     "zod": "4.4.3"
   },
   "devDependencies": {
-    "@astrale-os/adapter-cloudflare": "0.5.0-beta.134",
+    "@astrale-os/adapter-cloudflare": "0.5.0-beta.155",
     "@astrale-os/ox": ">=0.1.4 <1.0.0",
-    "@astrale-os/shell": "0.5.0-beta.18",
-    "@astrale-os/shell-react": "0.4.0-beta.17",
-    "@astrale-os/ui": "0.3.0-beta.25",
+    "@astrale-os/shell": "0.6.0-beta.3",
+    "@astrale-os/shell-react": "0.5.0-beta.3",
+    "@astrale-os/ui": "0.3.0-beta.31",
     "@tailwindcss/vite": "^4.3.3",
     "@tanstack/react-router": "1.170.18",
     "@tanstack/router-plugin": "1.168.23",
@@ -46,7 +46,7 @@
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.4",
     "@vitejs/plugin-react": "^6.1.0",
-    "bun": "1.4.0",
+    "bun": "1.4.2",
     "jsdom": "30.0.1",
     "mermaid": "^11.17.0",
     "oxlint": ">=1.79.0 <2.0.0",
@@ -58,7 +58,7 @@
     "type-fest": "^5.8.0",
     "typescript": "7.0.2",
     "vite": "^8.2.2",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.1"
   },
   "engines": {
     "node": ">=22.13"