core/

Package archive is the Hubtask archive format of backup-restore.md §3: what a backup writes and what a restore reads, as a reader and a writer over the backup target port.

Package catalogue is the list of every use case this build has, once.

Package condition is the vocabulary an expression may use, and the shape of what it is told.

Package activity declares how an item's history is written and how it is read back.

Package admin holds the control plane's outbound ports (multi-tenancy.md §5).

Package audit declares how the evidence trail is read back.

Package automation is the repository port of the rules (automation.md §1).

Package backup is the outbound port for the targets a tenant has configured.

Package idempotency declares what the idempotency guard needs from storage.

Package identity declares what the identity use cases need from storage.

Package importer is the outbound side of an import: the run's repository, and the converter port - a foreign file in, archive records out.

Package integration holds the repository ports of what reaches into this system from outside it: today the calendar feeds, later the webhook subscriptions beside them.

Package job is the outbound port for background work as a caller sees it.

Package jumble is the repository port of the inbox (domain-model.md §2).

Package lifecycle declares what the end of data's life needs stored: the instructions not to delete, and the record of what was deleted anyway.

Package mail is the store of a workspace's mail intake (ADR-0094): its settings, the receipts of what it received, and the lookups that route a message.

Package media declares what the media use cases need from storage of the *records* - the rows beside the bytes.

Package meta declares what the self-description needs from storage.

Package notification declares what the notification path needs from storage: the records it writes, and the preferences it honours.

Package outbox declares how a domain event leaves the write path.

Package privacy declares what data subject rights need stored: the case, the consent, and the two marks an erasure leaves on things it does not delete.

Package quota holds the outbound ports of the §4 limits (multi-tenancy.md).

Package sealing is the census a rotation ends on (ADR-0045, security.md §8.1): how many stored values still name each master key, and in which kind of value.

Package streams holds the outbound port of the partitioned streams' maintenance: activity entries, outbox events and rule runs partition by month, the leader keeps the coming months existing, and the retention engine drops what has wholly aged out.

Package suggestion is the outbound port of what AI proposed.

Package sync declares what offline clients need recorded about a change.

Package view declares how the application layer stores saved views.

Package voice is the store of a workspace's voice settings (ADR-0093).

Package work declares what the work management use cases need from storage.

Package access decides whether an actor may do something.

Package admin holds the control plane's use cases: the lifecycle of a tenant, as multi-tenancy.md §5 draws it.

Package audit is the trail as somebody reads it: a page of it, an archive of it, and the check that it has not been rewritten (audit.md §5).

Package automation holds the use cases that write the rules (automation.md §1).

Package backup is where an operator says where backups go, and finds out whether they can (backup-restore.md §2).

Package idempotency makes a repeated write harmless.

Package identity holds the use cases that turn a credential into an actor.

Package importer is an import from another system (backup-restore.md §9): the use case that accepts one, the read that answers its report, and the job that runs it.

Package integration holds the use cases that let another system reach into this one, and this one reach out: today the webhook subscriptions, later the trigger polling and the jumble's inbound routes.

Package job is the caller's half of the queue: finding out how a piece of background work is getting on, and stopping it.

Package jumble holds the use cases of the inbox (domain-model.md §5): something arrives, is listed, and becomes work or ages out.

Package lifecycle is where data stops existing: the hard delete, and the rules that decide when it is allowed (ADR-0020, data-retention.md).

Package mail is the administration of a workspace's mail intake (ADR-0094): its settings, its log, a collection's handle, and the address a notification's reply goes to.

Package media is the upload life of a file: staged, carried to storage by somebody other than this server, confirmed, and eventually reclaimed (arc42 §8.4).

Package meta answers what this installation is and what it can do.

Package notification is the application half of the Notification context: the consumer that turns events into records, and the delivery that turns a record into a message.

Package platform writes the installation's events: what a provider's purchase platform learns about a workspace (UC-INS-14, multi-tenancy.md §4.3).

Package privacy is data subject rights as use cases rather than as a support process (data-protection.md §4, ADR-0018 decision 4).

Package quota turns multi-tenancy.md §4's table into enforcement: per-tenant limits from `tenant.settings.quotas` with the mode's defaults, one resolution, one refusal shape.

Package sealing is the half of a key rotation that lets it finish (ADR-0045, security.md §8.1).

Package suggestion is the application layer of what AI proposed.

Package sync is the application half of the change stream: what a client is allowed to be told about, and where in the log it stands (ADR-0021).

Package voice turns what a person says to a voice assistant into work (ADR-0093): entries put on a list, a list read out, an entry ticked off, the day's due entries told.

Package work holds the work management use cases: containers and the items inside them.

Package shared holds what every use case needs regardless of its context: who is acting, in which tenant, with which permissions, and in which language the answer is to be rendered.

Package usecase is the catalogue: every use case the system has, once.

Package event holds the domain events: what happened, in a form other systems can subscribe to.

Package activity holds an item's own history: what happened to a piece of work, in the words the people working on it read (arc42 §5.2, the "Audit & Activity" context).

Package automation holds the rule: what starts a run, what has to be true for it to go on, and what it then does (automation.md §1, ADR-0009).

Package backup is where a backup goes and what has to be true before it may go there (backup-restore.md §2, ADR-0019).

Package entitlement holds the features a plan may leave out of a workspace (multi-tenancy.md §4.2), and what a workspace makes of the set its plan leaves out.

Package identity holds the model of who acts: accounts, their credentials, and the tokens that stand in for them when nobody is at a keyboard.

Package importer is an import from another system (backup-restore.md §9): a file somebody exported elsewhere, converted into the records a backup archive holds and applied through the restore.

Package integration holds the model of what reaches into this system from outside it, or lets something outside read it: today the calendar feed, later the webhooks that share its table section in the schema.

Package job is background work as the caller who asked for it sees it.

Package jumble is the inbox before the work exists (domain-model.md §2): entries arrive over four channels - a mail, a webhook, a quick capture, a plain API call - and become work items by conversion, or age out by dismissal.

Package lifecycle is the bounded context that decides when data stops existing: retention rules, the safeguards that override them, and the record of what was removed (ADR-0020, data-retention.md).

Package mail is the mail intake's own rules (ADR-0094): where a message is meant to go - read off its subject and the address it was sent to - and who may write at all.

Package media is the Media context's domain: what an uploaded object is, and how it may be served (arc42 §5.2).

Package notification is the Notification context arc42 §5.2 names: what somebody is to be told, what they have said about being told it, and how far that got.

Package plan holds a plan: a provider's group of workspaces with its own limits, locked values and the features it leaves out, between the installation and the workspace (multi-tenancy.md §4.2, ADR-0086).

Package privacy is the bounded context of data subject rights (data-protection.md §4, ADR-0018): the case somebody's exercised right becomes, the deadline it carries, and the consent that can be taken back.

Package shared holds the vocabulary every bounded context needs: identifiers, locales, and the error model.

Package suggestion is what AI proposed, and did not do (ADR-0012).

Package sync holds the offline synchronisation context's own entities (offline-sync.md §10): what the server keeps about the devices that synchronise, beside the change log they read.

Package view holds the query language every view is drawn from: the filter grammar of api-guidelines.md §3, what may be asked of which field, and the bounds a query has to stay inside.

Package voice is what a spoken sentence means to Hubtask (ADR-0093): the things named, their amounts and the place they go.

Package work holds the model of what is being managed: containers, items, and the policy that says what each kind of item can do.

Package service holds the domain services: the rules that belong to no single entity.

Package ai is the outbound half of ADR-0012: the port through which this product may ask a model something, and never a dependency of anything inwards of it.

Package audit is the port for the evidence trail (audit.md, ADR-0017).

Package backupstorage is the port a backup target sits behind (backup-restore.md §2, ADR-0019).

Package clock is the port for the one thing that makes otherwise pure code untestable: the current time.

Package crypto is the port for keeping a value unreadable to whoever holds the storage it sits on (backup-restore.md §4, security.md §8).

Package environment is the port for the entire configuration.

Package eventbus is the port for the delivery half of the outbox (ADR-0007).

Package expression is what a condition is, and nothing about how one is evaluated.

Package health carries the health model from ADR-0016.

Package httpclient is the port for calls that leave the process: webhooks, automation actions, AI providers, OIDC discovery.

Package i18n is the port for the declared exception to rule 8.

Package identityprovider is the relying-party half of ADR-0005, as the application layer needs it: send somebody to their company's provider, and turn what comes back into a verified identity.

Package mail is the port for the one notification channel that sends (arc42 §5.2).

Package mailbox is how the mail intake reads a connected mailbox (ADR-0094 decision 1): sign in, take the messages not yet taken, move each to the done folder once it is filed.

Package passkey is the seam the application layer checks a WebAuthn ceremony through (identity.md §23, ADR-0085).

Package persistence is the port for transactional storage.

Package queue is the port for work that happens outside a request: the job queue, the handlers that run on it, and the leader that exists exactly once (ADR-0008).

Package recurrence is the port for reading an RFC 5545 recurrence rule and turning it into the moments it means (ADR-0008, arc42 §11 R-07).

Package stepup is the seam a destructive act asks for a second, stronger proof of identity through (identity.md §16, backup-restore.md §8.3, security.md §5).

Package storage is the port for object storage: the bytes a person attaches to their work (arc42 §5.2 Media, §8.4).

Package text is the port for the two things the domain has to do to text and may not do itself (i18n-l10n.md §5, §7): bring an input to its Unicode normal form, and bring the domain half of an address to the ASCII form a mail server sees.

Package concurrency is the only place in the project where a `go` statement may appear.

Package correlation carries the request-scoped identifiers that every signal is joined on: the request ID and the tenant (observability-reliability.md §3.1).

Package secret provides a type that cannot accidentally be written to a log.