anton-bakker-feedback 0.4.3 → 1.0.0

package/dist/react/admin/FeedbackListPage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FeedbackListPage.d.ts","sourceRoot":"","sources":["../../../src/react/admin/FeedbackListPage.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAsB,cAAc,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC5F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAiBxD,iBAAS,WAAW,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,cAAc,CAAA;CAAE,qBAE1D;AAED,iBAAS,SAAS,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,qBAElD;AAED,QAAA,MAAM,gBAAgB,8FA0FrB,CAAC;AAGF,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"FeedbackListPage.d.ts","sourceRoot":"","sources":["../../../src/react/admin/FeedbackListPage.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAsB,cAAc,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC5F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAwBxD,iBAAS,WAAW,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,cAAc,CAAA;CAAE,qBAE1D;AAED,iBAAS,SAAS,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,qBAElD;AAED,QAAA,MAAM,gBAAgB,8FA0FrB,CAAC;AAGF,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC"}

package/dist/react/admin/FeedbackUpdatePage.d.ts

@@ -3,6 +3,12 @@ import { FeedbackUpdatePageProps } from './types.js';
  * FeedbackUpdatePage.tsx
  * Location: src/react/admin/FeedbackUpdatePage.tsx
  *
+ * @deprecated This component is deprecated and will be removed in a future version.
+ * Use FeedbackAnnotateClient.appendActivity() and FeedbackAnnotateClient.transitionStatus()
+ * from ingest-transport.ts instead. The whole-array corrections[] PATCH has been removed
+ * to prevent data loss (sagrosoft20-class silent drop). This shell is kept for backward
+ * compatibility during stage-3 consumer migration.
+ *
  * Admin update page for editing mutable fields of a feedback item.
  * Uses UpdatePage + EnumField + TextField + TextareaField from anton-bakker-tailwind-components.
  */

package/dist/react/admin/FeedbackUpdatePage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FeedbackUpdatePage.d.ts","sourceRoot":"","sources":["../../../src/react/admin/FeedbackUpdatePage.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAiC1D,QAAA,MAAM,kBAAkB,gGAiMvB,CAAC;AAGF,OAAO,EAAE,kBAAkB,EAAE,CAAC"}
+{"version":3,"file":"FeedbackUpdatePage.d.ts","sourceRoot":"","sources":["../../../src/react/admin/FeedbackUpdatePage.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAiC1D,QAAA,MAAM,kBAAkB,gGA6LvB,CAAC;AAGF,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/react/admin/LifecycleControls.d.ts

@@ -0,0 +1,28 @@
+import { StoredFeedbackItem } from '../../core/types.js';
+import { FeedbackAnnotateClient } from '../../core/ingest-transport.js';
+import { CapabilityKey } from './hooks/can.js';
+/**
+ * LifecycleControls.tsx
+ * Location: src/react/admin/LifecycleControls.tsx
+ *
+ * Legal+authorized transition buttons, assignment, duplicate merge via transitionStatus.
+ * Surfaces AnnotateResult.conflictReason inline.
+ * Renders only transition buttons for targets where can(requiredCapability) is true.
+ */
+import * as React from 'react';
+export interface LifecycleControlsProps {
+    feedbackId: string;
+    item: StoredFeedbackItem;
+    currentUser: {
+        userId: string;
+        name?: string;
+    };
+    can: (cap: CapabilityKey) => boolean;
+    transitionStatus: FeedbackAnnotateClient['transitionStatus'];
+    onTransitioned?: () => void;
+}
+/**
+ * LifecycleControls renders only transition buttons for targets where can(requiredCapability) is true.
+ */
+export declare const LifecycleControls: React.ForwardRefExoticComponent<LifecycleControlsProps & React.RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=LifecycleControls.d.ts.map

package/dist/react/admin/LifecycleControls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LifecycleControls.d.ts","sourceRoot":"","sources":["../../../src/react/admin/LifecycleControls.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,kBAAkB,EAAkB,MAAM,qBAAqB,CAAC;AAC9E,OAAO,KAAK,EAAE,sBAAsB,EAA2B,MAAM,gCAAgC,CAAC;AACtG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpD,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,kBAAkB,CAAC;IACzB,WAAW,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C,GAAG,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,OAAO,CAAC;IACrC,gBAAgB,EAAE,sBAAsB,CAAC,kBAAkB,CAAC,CAAC;IAC7D,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;CAC7B;AA8BD;;GAEG;AACH,eAAO,MAAM,iBAAiB,+FA6H7B,CAAC"}

package/dist/react/admin/__tests__/ActivityTimeline.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ActivityTimeline.test.d.ts.map

package/dist/react/admin/__tests__/ActivityTimeline.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityTimeline.test.d.ts","sourceRoot":"","sources":["../../../../src/react/admin/__tests__/ActivityTimeline.test.tsx"],"names":[],"mappings":""}

package/dist/react/admin/__tests__/AnnotationComposer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AnnotationComposer.test.d.ts.map

package/dist/react/admin/__tests__/AnnotationComposer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnnotationComposer.test.d.ts","sourceRoot":"","sources":["../../../../src/react/admin/__tests__/AnnotationComposer.test.tsx"],"names":[],"mappings":""}

package/dist/react/admin/__tests__/LifecycleControls.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LifecycleControls.test.d.ts.map

package/dist/react/admin/__tests__/LifecycleControls.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LifecycleControls.test.d.ts","sourceRoot":"","sources":["../../../../src/react/admin/__tests__/LifecycleControls.test.tsx"],"names":[],"mappings":""}

package/dist/react/admin/hooks/can.d.ts

@@ -0,0 +1,47 @@
+import { StoredFeedbackItem } from '../../../core/types.js';
+
+/**
+ * Capability keys for feedback operations.
+ * Each key grants permission for a specific action on feedback items.
+ */
+export type CapabilityKey = 'feedback:comment' | 'feedback:annotate' | 'feedback:triage' | 'feedback:assign' | 'feedback:resolve' | 'feedback:verify' | 'feedback:reopen' | 'feedback:reject' | 'feedback:delete';
+/**
+ * Record mapping each capability key to itself.
+ * Facilitates autocomplete and exhaustiveness checking.
+ */
+export declare const CAPABILITIES: Record<CapabilityKey, CapabilityKey>;
+/**
+ * User identity with resolved capabilities.
+ * Consuming apps (PEP) translate their identity system to this format at the system boundary.
+ */
+export interface CapabilityUser {
+    userId: string;
+    capabilities: Set<CapabilityKey>;
+}
+/** Alias for CapabilityUser — both names refer to the same type. */
+export type UserWithCapabilities = CapabilityUser;
+/**
+ * Pure capability-based authorization guard.
+ * Returns true if the user has the specified capability OR if ownership rules grant it.
+ *
+ * Ownership rules:
+ * - Submitters (userId === item.submittedBy) can comment and annotate without explicit capability
+ * - Reporters (userId in item.reporters[].userId) can comment and annotate without explicit capability
+ * - All other capabilities require explicit presence in user.capabilities
+ *
+ * @param capability - The capability being checked
+ * @param item - The feedback item
+ * @param user - The user with resolved capabilities
+ * @returns true if authorized, false otherwise
+ *
+ * @example
+ * const user = { userId: 'alice', capabilities: new Set(['feedback:triage']) };
+ * can('feedback:triage', item, user)  // → true (explicit capability)
+ * can('feedback:comment', item, user) // → false (no capability, not owner)
+ *
+ * const submitter = { userId: item.submittedBy, capabilities: new Set([]) };
+ * can('feedback:comment', item, submitter) // → true (ownership rule)
+ * can('feedback:triage', item, submitter)  // → false (ownership doesn't grant admin capabilities)
+ */
+export declare function can(capability: CapabilityKey, item: StoredFeedbackItem, user: CapabilityUser): boolean;
+//# sourceMappingURL=can.d.ts.map

package/dist/react/admin/hooks/can.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"can.d.ts","sourceRoot":"","sources":["../../../../src/react/admin/hooks/can.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;GAGG;AACH,MAAM,MAAM,aAAa,GACrB,kBAAkB,GAClB,mBAAmB,GACnB,iBAAiB,GACjB,iBAAiB,GACjB,kBAAkB,GAClB,iBAAiB,GACjB,iBAAiB,GACjB,iBAAiB,GACjB,iBAAiB,CAAC;AAEtB;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,aAAa,EAAE,aAAa,CAU7D,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,GAAG,CAAC,aAAa,CAAC,CAAC;CAClC;AAED,oEAAoE;AACpE,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,GAAG,CACjB,UAAU,EAAE,aAAa,EACzB,IAAI,EAAE,kBAAkB,EACxB,IAAI,EAAE,cAAc,GACnB,OAAO,CAiBT"}

package/dist/react/admin/hooks/useStatusTransition.d.ts

@@ -1,5 +1,19 @@
 import { FeedbackStatus } from '../../../core/types.js';
 
+/**
+ * Exhaustive legal transitions for the 12-state QA lifecycle. Readonly so consumers and
+ * tests can enumerate legal pairs. No self-loops.
+ */
+export declare const QA_LIFECYCLE_TRANSITIONS: Readonly<Record<FeedbackStatus, readonly FeedbackStatus[]>>;
+/**
+ * Pure predicate: is a transition from `from` to `to` legal in the QA lifecycle?
+ * Self-transitions are never legal.
+ *
+ * @param from - current status
+ * @param to - proposed target status
+ * @returns true if the transition is encoded in QA_LIFECYCLE_TRANSITIONS
+ */
+export declare function canTransitionTo(from: FeedbackStatus, to: FeedbackStatus): boolean;
 export interface UseStatusTransitionResult {
     /** Statuses reachable from the current status (current status excluded) */
     allowedTargets: FeedbackStatus[];
@@ -11,8 +25,8 @@ export interface UseStatusTransitionResult {
  * @returns Object with `allowedTargets` — statuses the item can transition to
  *
  * @example
- * const { allowedTargets } = useStatusTransition('open');
- * // allowedTargets → ['approved', 'deferred', 'wontfix']
+ * const { allowedTargets } = useStatusTransition('new');
+ * // allowedTargets → ['triaged']
  */
 export declare function useStatusTransition(currentStatus: FeedbackStatus): UseStatusTransitionResult;
 //# sourceMappingURL=useStatusTransition.d.ts.map

package/dist/react/admin/hooks/useStatusTransition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useStatusTransition.d.ts","sourceRoot":"","sources":["../../../../src/react/admin/hooks/useStatusTransition.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAc7D,MAAM,WAAW,yBAAyB;IACxC,2EAA2E;IAC3E,cAAc,EAAE,cAAc,EAAE,CAAC;CAClC;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,cAAc,GAAG,yBAAyB,CAG5F"}
+{"version":3,"file":"useStatusTransition.d.ts","sourceRoot":"","sources":["../../../../src/react/admin/hooks/useStatusTransition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,SAAS,cAAc,EAAE,CAAC,CAahG,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,cAAc,GAAG,OAAO,CAGjF;AAED,MAAM,WAAW,yBAAyB;IACxC,2EAA2E;IAC3E,cAAc,EAAE,cAAc,EAAE,CAAC;CAClC;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,cAAc,GAAG,yBAAyB,CAG5F"}

package/dist/react/admin/index.d.ts

@@ -1,7 +1,20 @@
 export { FeedbackListPage, StatusBadge, TypeBadge } from './FeedbackListPage.js';
 export { FeedbackDetailPage } from './FeedbackDetailPage.js';
+/**
+ * @deprecated FeedbackUpdatePage is superseded by the enriched FeedbackDetailPage with appendActivity + transitionStatus.
+ * Use createIngestAnnotateClient + FeedbackDetailPage with the new IoC props instead.
+ * This export is kept for backward compatibility and will be removed in a future major version.
+ */
 export { FeedbackUpdatePage } from './FeedbackUpdatePage.js';
+export { ActivityTimeline } from './ActivityTimeline.js';
+export { AnnotationComposer } from './AnnotationComposer.js';
+export { LifecycleControls } from './LifecycleControls.js';
 export { useStatusTransition } from './hooks/useStatusTransition.js';
+export { can, CAPABILITIES } from './hooks/can.js';
+export type { CapabilityKey, CapabilityUser, UserWithCapabilities } from './hooks/can.js';
 export type { AdminPageProps, FeedbackListPageProps, FeedbackDetailPageProps, FeedbackUpdatePageProps, } from './types.js';
-export type { StoredFeedbackItem, FeedbackStatus, FeedbackType, FeedbackScope, FeedbackSize, FeedbackEnvironment, Reporter, DialogueEntry, CorrectionEntry, FeedbackContext, } from '../../core/types.js';
+export type { StoredFeedbackItem, FeedbackStatus, FeedbackType, FeedbackScope, FeedbackSize, FeedbackEnvironment, Reporter, DialogueEntry, CorrectionEntry, FeedbackContext, ActivityEntry, ActivityKind, ActivityActor, } from '../../core/types.js';
+export type { FeedbackAnnotateClient, AnnotateResult, TransitionStatusOptions, } from '../../core/ingest-transport.js';
+export { createIngestAnnotateClient } from '../../core/ingest-transport.js';
+export { normaliseStoredItem } from '../../core/normalisers.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/react/admin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/react/admin/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAGrE,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,QAAQ,EACR,aAAa,EACb,eAAe,EACf,eAAe,GAChB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/react/admin/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D;;;;GAIG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAG3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAGrE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAG1F,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,QAAQ,EACR,aAAa,EACb,eAAe,EACf,eAAe,EACf,aAAa,EACb,YAAY,EACZ,aAAa,GACd,MAAM,qBAAqB,CAAC;AAG7B,YAAY,EACV,sBAAsB,EACtB,cAAc,EACd,uBAAuB,GACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/react/admin/index.js

@@ -1,12 +1,21 @@
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import * as React from "react";
 import { ListPage, Badge, DetailPage, Button, DetailSection, DetailRow, UpdatePage, EnumField, TextField, TextareaField, SaveFooter } from "anton-bakker-tailwind-components";
+import { d } from "../../chunks/ingest-transport-DAA_pJNb.js";
+import { c } from "../../chunks/normalisers-Cbd-i4Jh.js";
 const STATUS_VARIANT = {
-  open: "warning",
-  approved: "default",
+  new: "warning",
+  triaged: "default",
+  assigned: "default",
+  in_progress: "default",
+  fixed: "success",
+  pending_retest: "warning",
+  verified: "success",
+  closed: "success",
   deferred: "secondary",
-  resolved: "success",
-  wontfix: "destructive"
+  rejected: "destructive",
+  duplicate: "secondary",
+  reopened: "warning"
 };
 const TYPE_VARIANT = {
   bug: "destructive",
@@ -21,7 +30,7 @@ function TypeBadge({ type }) {
   return /* @__PURE__ */ jsx(Badge, { variant: TYPE_VARIANT[type] ?? "secondary", children: type });
 }
 const FeedbackListPage = React.forwardRef(
-  ({ items, loading = false, onNavigate, className, emptyStateMessage, currentUser, ...rest }, ref) => {
+  ({ items, loading = false, onNavigate, className, emptyStateMessage, currentUser: _currentUser }, ref) => {
     const [search, setSearch] = React.useState("");
     const [statusFilter, setStatusFilter] = React.useState("");
     const [typeFilter, setTypeFilter] = React.useState("");
@@ -135,7 +144,7 @@ function parseStructuredContent(content) {
   return { header, fields, raw: content };
 }
 const FeedbackDetailPage = React.forwardRef(
-  ({ feedbackId, fetchItem, getScreenshotUrl, onNavigate, currentUser, className }, ref) => {
+  ({ feedbackId, fetchItem, getScreenshotUrl, onNavigate, currentUser: _currentUser, className }, ref) => {
     const [item, setItem] = React.useState(null);
     const [loading, setLoading] = React.useState(true);
     const [error, setError] = React.useState(null);
@@ -224,15 +233,22 @@ const FeedbackDetailPage = React.forwardRef(
   }
 );
 FeedbackDetailPage.displayName = "FeedbackDetailPage";
-const ALLOWED_TRANSITIONS = {
-  open: ["approved", "deferred", "wontfix"],
-  approved: ["open", "resolved", "deferred"],
-  deferred: ["open", "approved", "wontfix"],
-  resolved: ["open", "approved"],
-  wontfix: ["open", "deferred"]
+const QA_LIFECYCLE_TRANSITIONS = {
+  new: ["triaged"],
+  triaged: ["assigned", "deferred", "rejected", "duplicate"],
+  assigned: ["in_progress", "deferred"],
+  in_progress: ["fixed", "deferred"],
+  fixed: ["pending_retest"],
+  pending_retest: ["verified", "reopened"],
+  verified: ["closed", "reopened"],
+  closed: ["reopened"],
+  rejected: ["reopened"],
+  duplicate: ["reopened"],
+  reopened: ["triaged", "assigned", "in_progress"],
+  deferred: ["triaged"]
 };
 function useStatusTransition(currentStatus) {
-  const allowedTargets = ALLOWED_TRANSITIONS[currentStatus] ?? [];
+  const allowedTargets = [...QA_LIFECYCLE_TRANSITIONS[currentStatus] ?? []];
   return { allowedTargets };
 }
 const STATUS_OPTIONS = [
@@ -266,7 +282,7 @@ const FeedbackUpdatePage = React.forwardRef(
     const [item, setItem] = React.useState(null);
     const [loading, setLoading] = React.useState(true);
     const [saving, setSaving] = React.useState(false);
-    const [status, setStatus] = React.useState("open");
+    const [status, setStatus] = React.useState("new");
     const [type, setType] = React.useState("bug");
     const [scope, setScope] = React.useState("");
     const [size, setSize] = React.useState("");
@@ -300,6 +316,10 @@ const FeedbackUpdatePage = React.forwardRef(
     const isDirty = item && (status !== item.status || type !== item.type || scope !== (item.scope ?? "") || size !== (item.size ?? "") || assignedTo !== (item.assignedTo ?? "") || tags !== (item.tags?.join(", ") ?? ""));
     const handleSave = async () => {
       if (!item) return;
+      if (!updateItem) {
+        console.warn("FeedbackUpdatePage: updateItem prop not provided. This component is deprecated.");
+        return;
+      }
       setSaving(true);
       try {
         const patch = { lastModifiedAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -310,23 +330,10 @@ const FeedbackUpdatePage = React.forwardRef(
         if (assignedTo !== (item.assignedTo ?? "")) patch.assignedTo = assignedTo || void 0;
         const newTags = tags.split(",").map((t) => t.trim()).filter(Boolean);
         if (JSON.stringify(newTags) !== JSON.stringify(item.tags ?? [])) patch.tags = newTags;
-        if (status === "resolved" && item.status !== "resolved") {
+        if (status === "closed" && item.status !== "closed") {
           patch.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
           patch.resolvedBy = currentUser?.userId ?? "unknown";
         }
-        if (classificationChanged && correctionNote) {
-          patch.corrections = [
-            ...item.corrections ?? [],
-            {
-              field: [type !== item.type && "type", scope !== (item.scope ?? "") && "scope", size !== (item.size ?? "") && "size"].filter(Boolean).join(", "),
-              before: { type: item.type, scope: item.scope, size: item.size },
-              after: { type, scope: scope || void 0, size: size || void 0 },
-              correctedBy: currentUser?.userId ?? "unknown",
-              correctedAt: (/* @__PURE__ */ new Date()).toISOString(),
-              reason: correctionNote
-            }
-          ];
-        }
         await updateItem(feedbackId, patch);
         onNavigate(`/feedback/${feedbackId}`);
       } finally {
@@ -346,7 +353,7 @@ const FeedbackUpdatePage = React.forwardRef(
             Button,
             {
               onClick: handleSave,
-              disabled: saving || !isDirty || !!classificationChanged && !correctionNote,
+              disabled: saving || !isDirty,
               children: saving ? "Saving…" : "Save changes"
             }
           )
@@ -441,12 +448,288 @@ const FeedbackUpdatePage = React.forwardRef(
   }
 );
 FeedbackUpdatePage.displayName = "FeedbackUpdatePage";
+function ActivityTimeline({ activity, className }) {
+  if (activity.length === 0) {
+    return /* @__PURE__ */ jsx("div", { "data-testid": "activity-timeline", className, children: /* @__PURE__ */ jsx("div", { "data-testid": "activity-empty-state", children: "No activity yet." }) });
+  }
+  return /* @__PURE__ */ jsx("div", { "data-testid": "activity-timeline", className, children: activity.map((entry) => /* @__PURE__ */ jsxs("div", { "data-testid": "activity-entry", children: [
+    /* @__PURE__ */ jsx("span", { "data-testid": "activity-kind-badge", children: entry.kind.replace(/_/g, " ") }),
+    /* @__PURE__ */ jsx("span", { "data-testid": "activity-actor", children: entry.actor.displayName }),
+    /* @__PURE__ */ jsx("span", { "data-testid": "activity-timestamp", children: entry.occurredAt }),
+    entry.body !== void 0 && /* @__PURE__ */ jsx("span", { "data-testid": "activity-body", children: entry.body })
+  ] }, entry.id)) });
+}
+const AnnotationComposer = React.forwardRef(
+  (props, ref) => {
+    const { feedbackId, currentUser, can: can2, appendActivity, appSource, onAppended } = props;
+    const canComment = can2("feedback:comment");
+    const canAnnotate = can2("feedback:annotate");
+    const [body, setBody] = React.useState("");
+    const [conflictReason, setConflictReason] = React.useState(void 0);
+    const [submitting, setSubmitting] = React.useState(false);
+    if (!canComment && !canAnnotate) return null;
+    const submit = async (kind) => {
+      setSubmitting(true);
+      setConflictReason(void 0);
+      const entry = {
+        id: crypto.randomUUID(),
+        actor: { userId: currentUser.userId, displayName: currentUser.name ?? currentUser.userId },
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        source: appSource,
+        kind,
+        body,
+        schemaVersion: 1
+      };
+      const result = await appendActivity(feedbackId, entry);
+      if (result.success) {
+        setBody("");
+        setConflictReason(void 0);
+        onAppended?.();
+      } else {
+        setConflictReason(result.conflictReason ?? result.error ?? "Unknown error");
+      }
+      setSubmitting(false);
+    };
+    const isDisabled = body.trim().length === 0 || submitting;
+    return /* @__PURE__ */ jsxs("div", { ref, "data-testid": "annotation-composer", className: "space-y-3", children: [
+      /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          "data-testid": "annotation-textarea",
+          value: body,
+          onChange: (e) => setBody(e.target.value),
+          placeholder: "Add a comment, note, question, or answer...",
+          className: "w-full min-h-[100px] p-3 border border-input rounded-md bg-background text-sm resize-y focus:outline-none focus:ring-2 focus:ring-ring"
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 flex-wrap", children: [
+        canComment && /* @__PURE__ */ jsx(
+          Button,
+          {
+            "data-testid": "annotation-comment-button",
+            disabled: isDisabled,
+            onClick: () => {
+              void submit("comment");
+            },
+            variant: "default",
+            size: "sm",
+            children: "Comment"
+          }
+        ),
+        canAnnotate && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              "data-testid": "annotation-note-button",
+              disabled: isDisabled,
+              onClick: () => {
+                void submit("note");
+              },
+              variant: "outline",
+              size: "sm",
+              children: "Note"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              "data-testid": "annotation-question-button",
+              disabled: isDisabled,
+              onClick: () => {
+                void submit("question");
+              },
+              variant: "outline",
+              size: "sm",
+              children: "Question"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              "data-testid": "annotation-answer-button",
+              disabled: isDisabled,
+              onClick: () => {
+                void submit("answer");
+              },
+              variant: "outline",
+              size: "sm",
+              children: "Answer"
+            }
+          )
+        ] })
+      ] }),
+      conflictReason !== void 0 && /* @__PURE__ */ jsx("div", { "data-testid": "annotation-conflict-reason", className: "text-sm text-destructive", children: conflictReason })
+    ] });
+  }
+);
+AnnotationComposer.displayName = "AnnotationComposer";
+const CAPABILITY_MAP = {
+  triaged: "feedback:triage",
+  assigned: "feedback:assign",
+  in_progress: "feedback:assign",
+  fixed: "feedback:resolve",
+  pending_retest: "feedback:resolve",
+  verified: "feedback:verify",
+  closed: "feedback:resolve",
+  deferred: "feedback:triage",
+  rejected: "feedback:reject",
+  duplicate: "feedback:reject",
+  reopened: "feedback:reopen"
+};
+function formatStatusLabel(status) {
+  return status.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+const LifecycleControls = React.forwardRef(
+  (props, ref) => {
+    const { feedbackId, item, can: can2, transitionStatus, onTransitioned } = props;
+    const { allowedTargets } = useStatusTransition(item.status);
+    const authorizedTargets = allowedTargets.filter((target) => {
+      const cap = CAPABILITY_MAP[target];
+      return cap !== void 0 && can2(cap);
+    });
+    const [duplicateInputVisible, setDuplicateInputVisible] = React.useState(false);
+    const [duplicateOf, setDuplicateOf] = React.useState("");
+    const [conflictReason, setConflictReason] = React.useState(void 0);
+    const [submitting, setSubmitting] = React.useState(false);
+    if (authorizedTargets.length === 0) return null;
+    const handleTransition = async (target) => {
+      if (target === "duplicate") {
+        if (!duplicateInputVisible) {
+          setDuplicateInputVisible(true);
+          return;
+        }
+        if (duplicateOf.trim().length === 0) {
+          setConflictReason("Duplicate target ID is required");
+          return;
+        }
+        setSubmitting(true);
+        setConflictReason(void 0);
+        const opts2 = {
+          currentStatus: item.status,
+          duplicateOf,
+          duplicateReporters: item.reporters
+        };
+        const result2 = await transitionStatus(feedbackId, "duplicate", opts2);
+        if (result2.success) {
+          setDuplicateInputVisible(false);
+          setDuplicateOf("");
+          setConflictReason(void 0);
+          onTransitioned?.();
+        } else {
+          setConflictReason(result2.conflictReason ?? result2.error ?? "Unknown error");
+        }
+        setSubmitting(false);
+        return;
+      }
+      setSubmitting(true);
+      setConflictReason(void 0);
+      const opts = {
+        currentStatus: item.status
+      };
+      const result = await transitionStatus(feedbackId, target, opts);
+      if (result.success) {
+        setConflictReason(void 0);
+        onTransitioned?.();
+      } else {
+        setConflictReason(result.conflictReason ?? result.error ?? "Unknown error");
+      }
+      setSubmitting(false);
+    };
+    return /* @__PURE__ */ jsxs("div", { ref, "data-testid": "lifecycle-controls", className: "space-y-3", children: [
+      /* @__PURE__ */ jsx("div", { className: "flex items-center gap-2 flex-wrap", children: authorizedTargets.map((target) => /* @__PURE__ */ jsx(
+        Button,
+        {
+          "data-testid": `lifecycle-${target}-button`,
+          onClick: () => {
+            void handleTransition(target);
+          },
+          disabled: submitting,
+          variant: target === "rejected" || target === "duplicate" ? "destructive" : "default",
+          size: "sm",
+          children: formatStatusLabel(target)
+        },
+        target
+      )) }),
+      duplicateInputVisible && /* @__PURE__ */ jsxs("div", { "data-testid": "duplicate-input-container", className: "space-y-2", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            "data-testid": "duplicate-of-input",
+            value: duplicateOf,
+            onChange: (e) => setDuplicateOf(e.target.value),
+            placeholder: "Canonical feedback ID (e.g., FB-2026-11-01-abc12345)",
+            className: "w-full p-2 border border-input rounded-md bg-background text-sm focus:outline-none focus:ring-2 focus:ring-ring"
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              onClick: () => {
+                void handleTransition("duplicate");
+              },
+              disabled: submitting || duplicateOf.trim().length === 0,
+              size: "sm",
+              children: "Confirm Duplicate"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              onClick: () => {
+                setDuplicateInputVisible(false);
+                setDuplicateOf("");
+                setConflictReason(void 0);
+              },
+              disabled: submitting,
+              variant: "outline",
+              size: "sm",
+              children: "Cancel"
+            }
+          )
+        ] })
+      ] }),
+      conflictReason !== void 0 && /* @__PURE__ */ jsx("div", { "data-testid": "lifecycle-conflict-reason", className: "text-sm text-destructive", children: conflictReason })
+    ] });
+  }
+);
+LifecycleControls.displayName = "LifecycleControls";
+const CAPABILITIES = {
+  "feedback:comment": "feedback:comment",
+  "feedback:annotate": "feedback:annotate",
+  "feedback:triage": "feedback:triage",
+  "feedback:assign": "feedback:assign",
+  "feedback:resolve": "feedback:resolve",
+  "feedback:verify": "feedback:verify",
+  "feedback:reopen": "feedback:reopen",
+  "feedback:reject": "feedback:reject",
+  "feedback:delete": "feedback:delete"
+};
+function can(capability, item, user) {
+  if (user.capabilities.has(capability)) {
+    return true;
+  }
+  const isSubmitter = user.userId === item.submittedBy;
+  const isReporter = item.reporters.some((r) => r.userId === user.userId);
+  if ((isSubmitter || isReporter) && (capability === "feedback:comment" || capability === "feedback:annotate")) {
+    return true;
+  }
+  return false;
+}
 export {
+  ActivityTimeline,
+  AnnotationComposer,
+  CAPABILITIES,
   FeedbackDetailPage,
   FeedbackListPage,
   FeedbackUpdatePage,
+  LifecycleControls,
   StatusBadge,
   TypeBadge,
+  can,
+  d as createIngestAnnotateClient,
+  c as normaliseStoredItem,
   useStatusTransition
 };
 //# sourceMappingURL=index.js.map