Dicta-Task

Table of Contents

• Overview
• Architecture
  • Pipeline (10 stages, batch)
  • Components
• Task Schema
• Policies
  • Confidence & Automation
  • Human Review Boundaries
  • Deduplication
  • Privacy & Retention
• Audit Trail
• Failure & Recovery
• Name
• Repository layout
• Quick start
• Deployment
• Testing
• Success metrics
• Where to go next
• Licence

Overview

dicta-task automates the ingestion of speech notes from a portable voice recorder into a structured, prioritised, auditable task list.

Plug in your recorder → dicta-task detects it, archives the audio, transcribes it, extracts tasks with confidence scores, deduplicates against your existing list, and either auto-applies high-confidence items or queues ambiguous ones for review.

Architecture

Pipeline (10 stages, batch)

Recorder USB
  → [1] udev/systemd detect
  → [2] Local archive (SHA-256 checksummed)
  → [3] Encrypted cloud backup (retry 3x / quarantine)
  → [4] Whisper/Vosk transcription → transcript JSON
  → [5] Haskell megaparsec NLP → candidate intents (with confidence)
  → [6] Normalise (resolve dates, assign priority scores)
  → [7] Deduplicate (exact + semantic matching)
  → [8] Review queue (low confidence) or auto-apply (high confidence)
  → [9] Canonical SQLite store → views (Markdown, JSON, CSV)
  → [10] Notify (dashboard / email alerts for review items)

Components

Component	Language/Tool	Purpose
Ingest	Rust	Detect recorder insertion (udev), archive audio, compute checksums, upload encrypted backup.
Transcription	Rust (whisper-rs / vosk)	Convert audio to text using offline ASR. No cloud dependency.
Task Parser	Haskell (megaparsec)	Extract tasks, deadlines, priorities from transcripts. Pure functions, idempotent.
Canonical Store	Rust + SQLite	Audited, versioned task database. WAL mode. JSON1 for structured fields.
Review System	Rust	Review queue for low-confidence items. Dashboard alerts.
ABI / Schema Proofs	Idris2	Dependent-type proofs for task schema correctness and confidence thresholds.
FFI Bridge	Zig	C-compatible bridge between Idris2 ABI and Rust components.
Deployment	Ansible + Terraform	Local machine setup (Ansible) + cloud provisioning (Terraform).

Task Schema

-- Haskell type (src/parse/)
data Task = Task
  { taskId             :: UUID
  , title              :: Text
  , description        :: Maybe Text
  , sourceAudioId      :: AudioHash     -- SHA-256 of source recording
  , sourceTranscriptId :: TranscriptId  -- reference to transcript version
  , createdAt          :: UTCTime
  , updatedAt          :: UTCTime
  , status             :: TaskStatus    -- Pending | InProgress | Done | ReviewNeeded
  , priorityScore      :: PriorityScore -- urgency * 0.5 + importance * 0.3 + deadline_proximity * 0.2
  , dueDate            :: Maybe Day
  , tags               :: [Text]
  , project            :: Maybe Text
  , supersedesTaskId   :: Maybe UUID    -- links to replaced task
  , duplicateOfTaskId  :: Maybe UUID    -- links to canonical duplicate
  , reviewState        :: ReviewState   -- Approved | PendingReview | Rejected
  , confidence         :: Confidence    -- 0.0–1.0, from parser
  , parserVersion      :: Version       -- which parser version produced this
  }

Policies

Confidence & Automation

Confidence	Threshold	Action
High	>= 0.8	Auto-apply to canonical store
Medium	0.3–0.8	Queue for human review
Low	< 0.3	Log only, do not create task candidate

Human Review Boundaries

Actions that always require confirmation:

• Deletions of existing tasks

• Deadline changes on existing tasks

• Low-confidence merges (semantic deduplication)

• Any update to a task marked Approved

Deduplication

• Exact match: Same title + same project → auto-merge

• Semantic duplicate: Similar intent, different wording → flag for review

• Recurring task: Same task pattern across recordings → link to parent with supersedesTaskId

Privacy & Retention

• Raw audio: Encrypted at rest, retained 30 days locally, cloud backup encrypted

• Transcripts: Stored locally only, redacted if sensitive content detected

• Cloud backups: Encrypted, configurable retention

• Secrets: Managed via rokur (Stapeln), never in code or repo

Audit Trail

Every task carries its full provenance chain:

original_audio_hash (SHA-256)
  → transcript_version (Whisper v3 / Vosk v0.3.45)
  → parser_version (dicta-task-parse v0.1.0)
  → change_set { timestamp, action, user_confirmation_state }

All transformations are logged for reproducibility. Reprocessing the same audio file with the same parser version MUST produce identical candidate tasks (idempotency).

Failure & Recovery

Failure	Handling
Failed cloud upload	Retry 3x with exponential backoff, then quarantine locally
Partial transcription	Flag for review, log incomplete segments
Corrupted audio file	Skip, log with checksum, alert user
Low-confidence parse	Route to review queue, never auto-apply
Dedup false positive	Show both candidates in review queue

All pipeline stages are idempotent — reprocessing the same input produces the same output.

Name

Dicta-Task (from dictate + task) was previously called dictask. The repository was renamed in September 2026; the old GitHub URL redirects.

Repository layout

The RSR layout applies (see the repository map). Project-specific locations:

Path	What lives there
src/ingest/	Rust crate: udev detection, archival (SHA-256), encrypted backup.
src/transcribe/	Rust crate: offline ASR (Whisper/Vosk).
src/parse/	Haskell package dicta-task-parse: megaparsec task extraction, dates, priority, dedup.
src/store/	Rust crate: SQLite canonical store + Markdown/JSON views.
src/interface/	Idris2 ABI (Abi/Task.idr), Zig FFI, generated C header.
src/definitions/schemas/	SQLite schema, JSON schema for candidate intents, CUE config schema.
src/definitions/config.ncl	Default pipeline configuration (Nickel).
build/deploy/	Ansible (local machine) and Terraform (cloud backup bucket).
build/container/	Stapeln container build.
docs/	Human documentation (architecture, onboarding, status, decisions).
.machine_readable/	Descriptiles, contractiles, policies read by tools.

Quick start

just                   # list all recipes
just build             # build all components
just test              # run all tests
just validate          # RSR structure + metadata checks

Per component, until the root recipes are wired to them:

(cd src/parse && cabal test)            # Haskell parser + tests
(cd src/store && cargo test)            # Rust store
(cd src/ingest && cargo run -- /media/recorder)

Deployment

(cd build/deploy/ansible && ansible-playbook setup.yml)   # udev, systemd, toolchains, SQLite
(cd build/deploy/terraform && terraform init && terraform apply)  # encrypted bucket, IAM

Testing

• Haskell parser: HSpec + QuickCheck property-based tests

• Rust components: cargo test with integration tests against real SQLite

• Pipeline replay: re-run historical audio through newer parser versions

• Idris2 proofs: compile-time verification

Success metrics

• % of tasks auto-processed vs. requiring manual review

• False positive/negative rates for intent detection

• Time saved vs. manual note-taking and task entry

• Pipeline end-to-end latency (target: < 5 minutes per recording)

Where to go next

• The repository map — generated; what every directory is for.

• EXPLAINME — the engineering deep-dive: how the pieces actually work.

• AFFIRMATION — the dated, signed honesty snapshot of the repo’s true state.

• AUDIT — the release audit gate.

• ROADMAP — what is built and what comes next.

• TOPOLOGY — pipeline topology and completion dashboard.

• ADR-0004 — why SQLite stays canonical (and where LMDB fits).

Licence

Code, configuration and scripts are Mozilla Public License 2.0 (MPL-2.0); prose documentation is CC-BY-SA-4.0. Both texts live in LICENSES/, and per-file SPDX-License-Identifier headers are authoritative. The GitHub-detected licence is MPL-2.0 (the root LICENSE). Long-term attribution uses Quantum-Safe Provenance — see the Quantum-Safe Provenance exhibit.