diff --git a/badges/tests.json b/badges/tests.json
index a337e7d..aeafa62 100644
--- a/badges/tests.json
+++ b/badges/tests.json
@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
   "label": "tests",
-  "message": "58 passed",
+  "message": "81 passed",
   "color": "brightgreen"
 }
diff --git a/demo/editmode.gif b/demo/editmode.gif
index edd91d9..5b9a644 100644
Binary files a/demo/editmode.gif and b/demo/editmode.gif differ
diff --git a/demo/notifications.gif b/demo/notifications.gif
index 0ab5092..0c5d060 100644
Binary files a/demo/notifications.gif and b/demo/notifications.gif differ
diff --git a/demo/quickstart.gif b/demo/quickstart.gif
index d5f2920..f815788 100644
Binary files a/demo/quickstart.gif and b/demo/quickstart.gif differ
diff --git a/demo/services.gif b/demo/services.gif
new file mode 100644
index 0000000..c4fd41e
Binary files /dev/null and b/demo/services.gif differ
diff --git a/demo/services.tape b/demo/services.tape
new file mode 100644
index 0000000..8d57873
--- /dev/null
+++ b/demo/services.tape
@@ -0,0 +1,159 @@
+# systab — Persistent Services
+# Creates a managed service (no timer), checks status, disables/enables,
+# inspects via edit mode, then cleans up.
+
+Output demo/services.gif
+Set Shell bash
+Set Width 1200
+Set Height 600
+Set FontSize 16
+
+Set TypingSpeed 50ms
+
+Sleep 1s
+
+# Create a persistent service
+Hide
+Type "./demo/note.sh 'Creating a persistent service job (runs on login, auto-restarts)'"
+Enter
+Sleep 500ms
+Show
+Sleep 1s
+Type "systab -s -n monitor -c 'sleep 3600'"
+Sleep 500ms
+Enter
+Sleep 2s
+
+# Check status — should show Type: Service, Active (running)
+Hide
+Type "./demo/note.sh 'Checking status — service is running'"
+Enter
+Sleep 500ms
+Show
+Sleep 1s
+Type "systab -S monitor"
+Sleep 500ms
+Enter
+Sleep 2s
+
+# Inspect the generated unit file
+Hide
+Type "./demo/note.sh 'Inspecting the generated unit file'"
+Enter
+Sleep 500ms
+Show
+Sleep 1s
+Type "cat ~/.config/systemd/user/systab_*.service | less"
+Sleep 500ms
+Enter
+Sleep 2s
+Type "/SYSTAB_TYPE"
+Enter
+Sleep 2s
+Type "q"
+Sleep 1s
+
+# View logs
+Hide
+Type "./demo/note.sh 'Viewing service logs'"
+Enter
+Sleep 500ms
+Show
+Sleep 1s
+Type "systab -L monitor"
+Sleep 500ms
+Enter
+Sleep 2s
+
+# Disable the service
+Hide
+Type "./demo/note.sh 'Disabling the service (stops it)'"
+Enter
+Sleep 500ms
+Show
+Sleep 1s
+Type "systab -D monitor"
+Sleep 500ms
+Enter
+Sleep 2s
+
+# Verify disabled
+Hide
+Type "./demo/note.sh 'Verifying service is disabled/stopped'"
+Enter
+Sleep 500ms
+Show
+Sleep 1s
+Type "systab -S monitor"
+Sleep 500ms
+Enter
+Sleep 2s
+
+# Re-enable
+Hide
+Type "./demo/note.sh 'Re-enabling the service'"
+Enter
+Sleep 500ms
+Show
+Sleep 1s
+Type "systab -E monitor"
+Sleep 500ms
+Enter
+Sleep 2s
+
+# Open edit mode — service appears with 'service' in schedule column
+Hide
+Type "./demo/note.sh 'Service jobs appear in edit mode with schedule = service'"
+Enter
+Sleep 500ms
+Show
+Sleep 1s
+Type "EDITOR=nano systab -e"
+Sleep 500ms
+Enter
+Sleep 3s
+
+# Just view and exit
+Ctrl+X
+Sleep 2s
+
+# Also show a service created via edit mode
+Hide
+Type "./demo/note.sh 'Creating a service via edit mode: new:s | service | cmd'"
+Enter
+Sleep 500ms
+Show
+Sleep 1s
+Type "EDITOR=nano systab -e"
+Sleep 500ms
+Enter
+Sleep 3s
+
+Ctrl+V
+Sleep 500ms
+Down 5
+Sleep 500ms
+Type "new:s,n=watcher | service | sleep 7200"
+Sleep 1s
+Enter
+
+Ctrl+O
+Sleep 500ms
+Enter
+Sleep 500ms
+Ctrl+X
+Sleep 3s
+
+# Final status
+Hide
+Type "./demo/note.sh 'Both services visible in status'"
+Enter
+Sleep 500ms
+Show
+Sleep 1s
+Type "systab -S"
+Sleep 500ms
+Enter
+Sleep 3s
+
+Sleep 2s
diff --git a/systab b/systab
index 3a36de2..1893189 100755
--- a/systab
+++ b/systab
@@ -26,6 +26,7 @@ opt_filter=""
 opt_output=""
 opt_name=""
 opt_jobid=""
+opt_service=false
 
 usage() {
     cat <<EOF
@@ -35,6 +36,7 @@ Create and manage systemd timer jobs with cron/at-like simplicity.
 
 Job Creation Options:
   -t <time>         Time specification (see TIME FORMATS below)
+  -s                Create a persistent service (no timer; mutually exclusive with -t/-i/-m/-o)
   -c <command>      Command string to execute
   -f <script>       Script file to execute
   -n <name>         Give the job a human-readable name (usable in place of hex ID)
@@ -72,6 +74,9 @@ EXAMPLES:
   # Read command from stdin
   echo "ls -la" | $SCRIPT_NAME -t "next monday at 9am"
 
+  # Create a persistent service job
+  $SCRIPT_NAME -s -n foobar -c "/usr/bin/foobar.sh"
+
   # Edit existing jobs (supports adding notifications via ID:flags syntax)
   $SCRIPT_NAME -e
 
@@ -198,21 +203,35 @@ job_id() {
     echo "${1#"${SCRIPT_NAME}"_}"
 }
 
-# Check if a job's timer is enabled
+# Check if a job's timer (or service) is enabled
 is_job_enabled() {
-    systemctl --user is-enabled "${1}.timer" &>/dev/null
+    if is_job_service "$1"; then
+        systemctl --user is-enabled "${1}.service" &>/dev/null
+    else
+        systemctl --user is-enabled "${1}.timer" &>/dev/null
+    fi
 }
 
-# Disable a job (stop + disable timer)
+# Disable a job (stop + disable timer or service)
 disable_job() {
-    systemctl --user stop "${1}.timer" 2>/dev/null || true
-    systemctl --user disable "${1}.timer" 2>/dev/null || true
+    if is_job_service "$1"; then
+        systemctl --user stop "${1}.service" 2>/dev/null || true
+        systemctl --user disable "${1}.service" 2>/dev/null || true
+    else
+        systemctl --user stop "${1}.timer" 2>/dev/null || true
+        systemctl --user disable "${1}.timer" 2>/dev/null || true
+    fi
 }
 
-# Enable a job (enable + start timer)
+# Enable a job (enable + start timer or service)
 enable_job() {
-    systemctl --user enable "${1}.timer" 2>/dev/null || true
-    systemctl --user start "${1}.timer" 2>/dev/null || true
+    if is_job_service "$1"; then
+        systemctl --user enable "${1}.service" 2>/dev/null || true
+        systemctl --user start "${1}.service" 2>/dev/null || true
+    else
+        systemctl --user enable "${1}.timer" 2>/dev/null || true
+        systemctl --user start "${1}.timer" 2>/dev/null || true
+    fi
 }
 
 # Resolve a job identifier (hex ID or name) to a 6-char hex ID
@@ -222,7 +241,8 @@ resolve_job_id() {
     # Try as hex ID first
     if [[ "$input" =~ ^[0-9a-f]{6}$ ]]; then
         local timer_file="$SYSTEMD_USER_DIR/${SCRIPT_NAME}_${input}.timer"
-        if [[ -f "$timer_file" ]]; then
+        local service_file="$SYSTEMD_USER_DIR/${SCRIPT_NAME}_${input}.service"
+        if [[ -f "$timer_file" ]] || { [[ -f "$service_file" ]] && grep -q "^# SYSTAB_TYPE=service$" "$service_file" 2>/dev/null; }; then
             _resolved_id="$input"
             return
         fi
@@ -247,6 +267,23 @@ get_job_name() {
     sed -n 's/^# SYSTAB_NAME=//p' "$service_file" 2>/dev/null || true
 }
 
+# Check if a job is a service-only job (not timer-backed)
+is_job_service() {
+    grep -q "^# SYSTAB_TYPE=service$" "$SYSTEMD_USER_DIR/${1}.service" 2>/dev/null
+}
+
+# Get managed service-only units (no timer)
+get_managed_service_jobs() {
+    [[ -d "$SYSTEMD_USER_DIR" ]] || return
+    local file
+    for file in "$SYSTEMD_USER_DIR"/*.service; do
+        [[ -f "$file" ]] || continue
+        grep -q "^$MARKER" "$file" 2>/dev/null || continue
+        grep -q "^# SYSTAB_TYPE=service$" "$file" 2>/dev/null || continue
+        basename "$file" .service
+    done
+}
+
 # Format a job identifier for display: "id (name)" or just "id"
 format_job_id() {
     local id="$1" name="$2"
@@ -262,9 +299,9 @@ validate_job_id() {
     resolve_job_id "$1"
     local id="$_resolved_id"
     _job_name="${SCRIPT_NAME}_${id}"
-    local timer_file="$SYSTEMD_USER_DIR/${_job_name}.timer"
-    [[ -f "$timer_file" ]] || error "No job found with ID: $id"
-    grep -q "^$MARKER" "$timer_file" 2>/dev/null || error "Not a managed job: $id"
+    local service_file="$SYSTEMD_USER_DIR/${_job_name}.service"
+    [[ -f "$service_file" ]] || error "No job found with ID: $id"
+    grep -q "^$MARKER" "$service_file" 2>/dev/null || error "Not a managed job: $id"
 }
 
 # Toggle a job's enabled state by short ID or name
@@ -303,11 +340,15 @@ get_managed_units() {
     done
 }
 
-# Build flags string from opt_notify, opt_email, and opt_name
+# Build flags string from opt_service, opt_notify, opt_email, and opt_name
 build_flags_string() {
     local flags=""
+    if $opt_service; then
+        flags="s"
+    fi
     if $opt_notify; then
-        flags="i"
+        [[ -n "$flags" ]] && flags+=","
+        flags+="i"
     fi
     if [[ -n "$opt_output" ]]; then
         [[ -n "$flags" ]] && flags+=","
@@ -331,9 +372,11 @@ parse_flags() {
     _email_addr=""
     _output_lines=""
     _name=""
+    _service_flag=false
     IFS=',' read -ra parts <<< "$flags"
     for part in "${parts[@]}"; do
         case "$part" in
+            s) _service_flag=true ;;
             i) _notify_flag=true ;;
             o) _output_lines=10 ;;
             o=*) _output_lines="${part#o=}" ;;
@@ -382,11 +425,12 @@ write_notify_lines() {
     fi
 }
 
-# Write service + timer unit files, enable and start the timer
-# Usage: _write_unit_files <command> <schedule> [flags]
+# Write service + timer unit files (or service-only), enable and start
+# Usage: _write_unit_files <command> <schedule> [flags] [job_type]
+#   job_type: "timer" (default) or "service"
 # Sets _created_id to the short ID of the new job
 _write_unit_files() {
-    local command_to_run="$1" schedule="$2" flags="${3-}"
+    local command_to_run="$1" schedule="$2" flags="${3-}" job_type="${4-timer}"
     local job_name short_id
 
     job_name="${SCRIPT_NAME}_$(generate_id)"
@@ -394,9 +438,40 @@ _write_unit_files() {
 
     mkdir -p "$SYSTEMD_USER_DIR"
 
-    # Service file
     local service_file="$SYSTEMD_USER_DIR/${job_name}.service"
-    cat > "$service_file" <<EOF
+
+    if [[ "$job_type" == "service" ]]; then
+        # Service-only unit (persistent, no timer)
+        cat > "$service_file" <<EOF
+$MARKER
+# SYSTAB_TYPE=service
+[Unit]
+Description=$SCRIPT_NAME service: $job_name
+
+[Service]
+Type=simple
+ExecStart=${SHELL:-/bin/bash} -c '$command_to_run'
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=$job_name
+Restart=on-failure
+EOF
+        if [[ -n "$flags" ]]; then
+            echo "# SYSTAB_FLAGS=$flags" >> "$service_file"
+            parse_flags "$flags"
+            [[ -n "$_name" ]] && echo "# SYSTAB_NAME=$_name" >> "$service_file"
+        fi
+        cat >> "$service_file" <<EOF
+
+[Install]
+WantedBy=default.target
+EOF
+        systemctl --user daemon-reload
+        systemctl --user enable "${job_name}.service"
+        systemctl --user start "${job_name}.service"
+    else
+        # Timer-backed unit
+        cat > "$service_file" <<EOF
 $MARKER
 [Unit]
 Description=$SCRIPT_NAME job: $job_name
@@ -409,16 +484,16 @@ StandardError=journal
 SyslogIdentifier=$job_name
 EOF
 
-    if [[ -n "$flags" ]]; then
-        echo "# SYSTAB_FLAGS=$flags" >> "$service_file"
-        parse_flags "$flags"
-        [[ -n "$_name" ]] && echo "# SYSTAB_NAME=$_name" >> "$service_file"
-        write_notify_lines "$short_id" "$_notify_flag" "$_email_addr" "$service_file" "$_output_lines" "$job_name" "$_name"
-    fi
+        if [[ -n "$flags" ]]; then
+            echo "# SYSTAB_FLAGS=$flags" >> "$service_file"
+            parse_flags "$flags"
+            [[ -n "$_name" ]] && echo "# SYSTAB_NAME=$_name" >> "$service_file"
+            write_notify_lines "$short_id" "$_notify_flag" "$_email_addr" "$service_file" "$_output_lines" "$job_name" "$_name"
+        fi
 
-    # Timer file
-    local timer_file="$SYSTEMD_USER_DIR/${job_name}.timer"
-    cat > "$timer_file" <<EOF
+        # Timer file
+        local timer_file="$SYSTEMD_USER_DIR/${job_name}.timer"
+        cat > "$timer_file" <<EOF
 $MARKER
 [Unit]
 Description=Timer for $SCRIPT_NAME job: $job_name
@@ -427,21 +502,22 @@ Description=Timer for $SCRIPT_NAME job: $job_name
 OnCalendar=$schedule
 EOF
 
-    if ! is_recurring "$schedule"; then
-        cat >> "$timer_file" <<'ONETIME'
+        if ! is_recurring "$schedule"; then
+            cat >> "$timer_file" <<'ONETIME'
 Persistent=false
 RemainAfterElapse=no
 ONETIME
-    fi
+        fi
 
-    cat >> "$timer_file" <<EOF
+        cat >> "$timer_file" <<EOF
 
 [Install]
 WantedBy=timers.target
 EOF
 
-    systemctl --user enable "$job_name.timer"
-    systemctl --user start "$job_name.timer"
+        systemctl --user enable "$job_name.timer"
+        systemctl --user start "$job_name.timer"
+    fi
 
     _created_id="$short_id"
 }
@@ -482,32 +558,53 @@ create_job() {
         check_name_unique "$opt_name"
     fi
 
-    local time_spec
-    time_spec=$(parse_time "$opt_time")
-
-    _write_unit_files "$command_to_run" "$time_spec" "$(build_flags_string)"
-    systemctl --user daemon-reload
-
-    local label
-    label=$(format_job_id "$_created_id" "$opt_name")
-    echo "Job created: $label"
-    local job_name="${SCRIPT_NAME}_${_created_id}"
-    echo "Next run: $(systemctl --user show "$job_name.timer" -p NextElapseUSecRealtime --value 2>/dev/null)"
+    local label job_name
+    if $opt_service; then
+        _write_unit_files "$command_to_run" "service" "$(build_flags_string)" service
+        systemctl --user daemon-reload
+        job_name="${SCRIPT_NAME}_${_created_id}"
+        label=$(format_job_id "$_created_id" "$opt_name")
+        echo "Service created: $label"
+        if systemctl --user is-active "${job_name}.service" &>/dev/null; then
+            echo "Status: Active (running)"
+        else
+            echo "Status: Inactive (check: systemctl --user status ${job_name}.service)"
+        fi
+    else
+        local time_spec
+        time_spec=$(parse_time "$opt_time")
+        _write_unit_files "$command_to_run" "$time_spec" "$(build_flags_string)"
+        systemctl --user daemon-reload
+        job_name="${SCRIPT_NAME}_${_created_id}"
+        label=$(format_job_id "$_created_id" "$opt_name")
+        echo "Job created: $label"
+        echo "Next run: $(systemctl --user show "$job_name.timer" -p NextElapseUSecRealtime --value 2>/dev/null)"
+    fi
 }
 
 # Remove a managed job (stop, disable, delete unit files)
 remove_job() {
     local job_name="$1"
-    systemctl --user stop "${job_name}.timer" 2>/dev/null || true
-    systemctl --user disable "${job_name}.timer" 2>/dev/null || true
-    rm -f "$SYSTEMD_USER_DIR/${job_name}.service" "$SYSTEMD_USER_DIR/${job_name}.timer"
+    if is_job_service "$job_name"; then
+        systemctl --user stop "${job_name}.service" 2>/dev/null || true
+        systemctl --user disable "${job_name}.service" 2>/dev/null || true
+        rm -f "$SYSTEMD_USER_DIR/${job_name}.service"
+    else
+        systemctl --user stop "${job_name}.timer" 2>/dev/null || true
+        systemctl --user disable "${job_name}.timer" 2>/dev/null || true
+        rm -f "$SYSTEMD_USER_DIR/${job_name}.service" "$SYSTEMD_USER_DIR/${job_name}.timer"
+    fi
 }
 
 # Create a job from edit mode (schedule + command + flags, prints short ID)
 create_job_from_edit() {
-    local schedule
-    schedule=$(parse_time "$1")
-    _write_unit_files "$2" "$schedule" "${3-}"
+    if [[ "$1" == "service" ]]; then
+        _write_unit_files "$2" "service" "${3-}" service
+    else
+        local schedule
+        schedule=$(parse_time "$1")
+        _write_unit_files "$2" "$schedule" "${3-}"
+    fi
     echo "$_created_id"
 }
 
@@ -528,7 +625,7 @@ edit_jobs() {
 # Add a line with "new" as ID to create a job: new | daily | /path/to/cmd
 # Comment out a line to disable, uncomment to re-enable.
 #
-# Flags (append to ID with ':'): i = desktop, e=addr = email,
+# Flags (append to ID with ':'): s = service, i = desktop, e=addr = email,
 #   o = include output (default 10 lines), o=N = include N lines of output,
 #   n=name = human-readable name (usable in place of hex ID)
 #   a1b2c3:i | daily | cmd               desktop notification
@@ -536,8 +633,11 @@ edit_jobs() {
 #   a1b2c3:n=backup,i | daily | cmd      named job with desktop notification
 #   a1b2c3:e=user@host | daily | cmd      email notification
 #   a1b2c3:i,e=user@host | daily | cmd    both
+#   a1b2c3:s | service | cmd             persistent service (no timer)
+#   new:s,n=name | service | cmd         new persistent service
 #
 # Schedule formats (systemd OnCalendar):
+#   service         persistent service (started on login, auto-restarted)
 #   hourly, daily, weekly, monthly, yearly
 #   *:0/15          every 15 minutes
 #   *-*-* 02:00:00  daily at 2am
@@ -570,6 +670,28 @@ HEADER
                 fi
             fi
         done < <(get_managed_units timer)
+
+        while IFS= read -r job; do
+            [[ -z "$job" ]] && continue
+
+            local service_file="$SYSTEMD_USER_DIR/${job}.service"
+            if [[ -f "$service_file" ]]; then
+                local id command flags id_field
+                id=$(job_id "$job")
+                command=$(get_job_command "$service_file")
+                flags=$(grep "^# SYSTAB_FLAGS=" "$service_file" 2>/dev/null | sed 's/^# SYSTAB_FLAGS=//' || true)
+                if [[ -n "$flags" ]]; then
+                    id_field="$id:$flags"
+                else
+                    id_field="$id:s"
+                fi
+                if is_job_enabled "$job"; then
+                    printf '%s | service | %s\n' "$id_field" "$command"
+                else
+                    printf '# %s | service | %s\n' "$id_field" "$command"
+                fi
+            fi
+        done < <(get_managed_service_jobs)
     } > "$temp_file"
 
     # Save original for diffing
@@ -603,6 +725,7 @@ HEADER
             sched="${sched%%|*}"
             trim "$sched"; sched="$_trimmed"
             [[ -z "$sched" ]] && continue
+            [[ "$sched" == "service" ]] && continue
             if ! (parse_time "$sched") &>/dev/null; then
                 echo "Bad schedule: \"$sched\"" >&2
                 errors=$((errors + 1))
@@ -831,7 +954,11 @@ HEADER
 
             # Only restart if the job is active (not being disabled)
             if ! $now_commented; then
-                systemctl --user restart "${jname}.timer" 2>/dev/null || true
+                if is_job_service "$jname"; then
+                    systemctl --user restart "${jname}.service" 2>/dev/null || true
+                else
+                    systemctl --user restart "${jname}.timer" 2>/dev/null || true
+                fi
             fi
 
             echo "Updated: $id"
@@ -871,13 +998,28 @@ build_job_list() {
 
 # Show status of all managed jobs (or a single job if opt_jobid is set)
 show_status() {
-    build_job_list timer || return
+    # Build combined list: timer jobs + service-only jobs
+    _job_list=()
+    if [[ -n "$opt_jobid" ]]; then
+        resolve_job_id "$opt_jobid"
+        _job_list+=("${SCRIPT_NAME}_${_resolved_id}")
+    else
+        local job
+        while IFS= read -r job; do
+            [[ -z "$job" ]] && continue
+            _job_list+=("$job")
+        done < <(get_managed_units timer; get_managed_service_jobs)
+    fi
+    if [[ ${#_job_list[@]} -eq 0 ]]; then
+        echo "No managed jobs found."
+        return
+    fi
 
     local count=${#_job_list[@]}
     echo "Managed Jobs Status - $count total"
     echo "=========================================="
     echo ""
-    
+
     for job in "${_job_list[@]}"; do
         local timer_file="$SYSTEMD_USER_DIR/${job}.timer"
         local service_file="$SYSTEMD_USER_DIR/${job}.service"
@@ -888,60 +1030,72 @@ show_status() {
         label=$(format_job_id "$id" "$name")
         echo "Job: $label"
 
-        # Get schedule from timer file
-        if [[ -f "$timer_file" ]]; then
-            local schedule
-            schedule=$(grep "^OnCalendar=" "$timer_file" | cut -d= -f2-)
-            echo "  Schedule: $schedule"
-            
-            # Check if recurring
-            if grep -q "^Persistent=false" "$timer_file"; then
-                echo "  Type: One-time"
-            else
-                echo "  Type: Recurring"
+        if is_job_service "$job"; then
+            # Service-only job display
+            echo "  Type: Service"
+            if [[ -f "$service_file" ]]; then
+                local command
+                command=$(get_job_command "$service_file")
+                echo "  Command: $command"
+            fi
+            if ! is_job_enabled "$job"; then
+                echo "  Service: Disabled"
+            else
+                local svc_active svc_sub
+                svc_active=$(systemctl --user show "${job}.service" -p ActiveState --value 2>/dev/null)
+                svc_sub=$(systemctl --user show "${job}.service" -p SubState --value 2>/dev/null)
+                echo "  Service: ${svc_active} (${svc_sub})"
+            fi
+        else
+            # Timer-backed job display
+            if [[ -f "$timer_file" ]]; then
+                local schedule
+                schedule=$(grep "^OnCalendar=" "$timer_file" | cut -d= -f2-)
+                echo "  Schedule: $schedule"
+                if grep -q "^Persistent=false" "$timer_file"; then
+                    echo "  Type: One-time"
+                else
+                    echo "  Type: Recurring"
+                fi
             fi
-        fi
-        
-        # Get command from service file
-        if [[ -f "$service_file" ]]; then
-            local command
-            command=$(get_job_command "$service_file")
-            echo "  Command: $command"
-        fi
-        
-        # Timer status
-        if ! is_job_enabled "$job"; then
-            echo "  Timer: Disabled"
-        elif systemctl --user is-active "${job}.timer" &>/dev/null; then
-            echo "  Timer: Active"
 
-            local next_run last_run
-            next_run=$(systemctl --user show "${job}.timer" -p NextElapseUSecRealtime --value 2>/dev/null)
-            last_run=$(systemctl --user show "${job}.timer" -p LastTriggerUSec --value 2>/dev/null)
-            [[ -n "$next_run" ]] && echo "  Next run: $next_run"
-            [[ -n "$last_run" ]] && echo "  Last run: $last_run"
-        else
-            echo "  Timer: Inactive/Completed"
-        fi
-        
-        # Service status
-        if systemctl --user is-failed "${job}.service" &>/dev/null; then
-            echo "  Service: Failed"
-        elif systemctl --user is-active "${job}.service" &>/dev/null; then
-            echo "  Service: Running"
-        else
-            local exit_status
-            exit_status=$(systemctl --user show "${job}.service" -p ExecMainStatus --value 2>/dev/null)
-            if [[ -n "$exit_status" && "$exit_status" != "0" ]]; then
-                echo "  Service: Completed with exit code $exit_status"
+            if [[ -f "$service_file" ]]; then
+                local command
+                command=$(get_job_command "$service_file")
+                echo "  Command: $command"
+            fi
+
+            if ! is_job_enabled "$job"; then
+                echo "  Timer: Disabled"
+            elif systemctl --user is-active "${job}.timer" &>/dev/null; then
+                echo "  Timer: Active"
+                local next_run last_run
+                next_run=$(systemctl --user show "${job}.timer" -p NextElapseUSecRealtime --value 2>/dev/null)
+                last_run=$(systemctl --user show "${job}.timer" -p LastTriggerUSec --value 2>/dev/null)
+                [[ -n "$next_run" ]] && echo "  Next run: $next_run"
+                [[ -n "$last_run" ]] && echo "  Last run: $last_run"
             else
-                echo "  Service: Completed"
+                echo "  Timer: Inactive/Completed"
+            fi
+
+            if systemctl --user is-failed "${job}.service" &>/dev/null; then
+                echo "  Service: Failed"
+            elif systemctl --user is-active "${job}.service" &>/dev/null; then
+                echo "  Service: Running"
+            else
+                local exit_status
+                exit_status=$(systemctl --user show "${job}.service" -p ExecMainStatus --value 2>/dev/null)
+                if [[ -n "$exit_status" && "$exit_status" != "0" ]]; then
+                    echo "  Service: Completed with exit code $exit_status"
+                else
+                    echo "  Service: Completed"
+                fi
             fi
         fi
-        
+
         echo ""
     done
-    
+
     # Show systemctl list-timers summary
     echo "Active Timers:"
     echo "--------------"
@@ -965,7 +1119,13 @@ list_logs() {
         label=$(format_job_id "$id" "$name")
         echo "=== Logs for $label ==="
 
-        if systemctl --user is-active "${job}.timer" &>/dev/null; then
+        if is_job_service "$job"; then
+            local svc_active svc_sub
+            svc_active=$(systemctl --user show "${job}.service" -p ActiveState --value 2>/dev/null)
+            svc_sub=$(systemctl --user show "${job}.service" -p SubState --value 2>/dev/null)
+            echo "Status: ${svc_active} (${svc_sub})"
+            systemctl --user status "${job}.service" --no-pager -l 2>/dev/null | head -n 3 || true
+        elif systemctl --user is-active "${job}.timer" &>/dev/null; then
             echo "Status: Active"
             systemctl --user status "${job}.timer" --no-pager -l | head -n 3
         else
@@ -1021,9 +1181,10 @@ clean_jobs() {
 
 # Parse command-line options
 parse_options() {
-    while getopts "t:c:f:n:im:oD:E:eLSCh" opt; do
+    while getopts "t:sc:f:n:im:oD:E:eLSCh" opt; do
         case $opt in
             t) opt_time="$OPTARG" ;;
+            s) opt_service=true ;;
             c) opt_command="$OPTARG" ;;
             f) opt_file="$OPTARG" ;;
             n) opt_name="$OPTARG" ;;
@@ -1093,7 +1254,7 @@ parse_options() {
         error "Options -D, -E, -e, -L, -S, and -C are mutually exclusive"
     fi
 
-    if [[ $manage_count -gt 0 && -n "$opt_time$opt_command$opt_file" ]]; then
+    if [[ $manage_count -gt 0 ]] && { [[ -n "$opt_time$opt_command$opt_file" ]] || $opt_service; }; then
         error "Management options -D, -E, -e, -L, -S, and -C cannot be used with job creation options"
     fi
     
@@ -1103,7 +1264,14 @@ parse_options() {
     
     # Validate create mode requirements
     if [[ $manage_count -eq 0 ]]; then
-        [[ -n "$opt_time" ]] || error "Option -t is required for job creation"
+        if $opt_service; then
+            [[ -z "$opt_time" ]] || error "Options -s and -t are mutually exclusive"
+            $opt_notify && error "Option -i is not supported for service jobs"
+            [[ -z "$opt_email" ]] || error "Option -m is not supported for service jobs"
+            [[ -z "$opt_output" ]] || error "Option -o is not supported for service jobs"
+        else
+            [[ -n "$opt_time" ]] || error "Option -t or -s is required for job creation"
+        fi
     fi
 }
 
diff --git a/test.sh b/test.sh
index fa7215f..79f6cbc 100755
--- a/test.sh
+++ b/test.sh
@@ -97,10 +97,10 @@ assert_file_contains() {
 # Track test-created job IDs for targeted cleanup
 test_job_ids=()
 
-# Extract job ID from "Job created: <id>" or "Job created: <id> (<name>)" output
+# Extract job ID from "Job created: <id>", "Service created: <id>", or with name suffix
 # Sets _extracted_id and appends to test_job_ids for cleanup tracking
 extract_id() {
-    _extracted_id=$(sed -n 's/^Job created: \([0-9a-f]\{6\}\)\( .*\)\{0,1\}$/\1/p' <<< "$_last_output")
+    _extracted_id=$(sed -n 's/^\(Job\|Service\) created: \([0-9a-f]\{6\}\)\( .*\)\{0,1\}$/\2/p' <<< "$_last_output")
     test_job_ids+=("$_extracted_id")
 }
 
@@ -333,6 +333,84 @@ else
     pass "-o without -i/-m has no ExecStopPost"
 fi
 
+# ============================================================
+# Services (-s)
+# ============================================================
+
+echo ""
+echo "${BOLD}--- Services ---${RESET}"
+
+# Create a persistent service job (sleep 3600 stays running)
+assert_output "create service job" "Service created:" $SYSTAB -s -c "sleep 3600"
+extract_id; id_svc=$_extracted_id
+
+if [[ -z "$id_svc" ]]; then
+    echo "FATAL: could not extract service job ID, aborting"
+    exit 1
+fi
+
+# Unit file checks (mirrors tape: cat the service file)
+assert_file_contains "service file has SYSTAB_TYPE=service" \
+    "$SYSTEMD_USER_DIR/systab_${id_svc}.service" "^# SYSTAB_TYPE=service$"
+assert_file_contains "service file has Type=simple" \
+    "$SYSTEMD_USER_DIR/systab_${id_svc}.service" "^Type=simple$"
+assert_file_contains "service file has Restart=on-failure" \
+    "$SYSTEMD_USER_DIR/systab_${id_svc}.service" "^Restart=on-failure$"
+assert_file_contains "service file has WantedBy=default.target" \
+    "$SYSTEMD_USER_DIR/systab_${id_svc}.service" "^WantedBy=default.target$"
+
+# No timer file should exist (mirrors tape: no timer)
+if [[ -f "$SYSTEMD_USER_DIR/systab_${id_svc}.timer" ]]; then
+    fail "service job has no .timer file" "timer file unexpectedly exists"
+else
+    pass "service job has no .timer file"
+fi
+
+# Service should be active (mirrors tape: "Active (running)")
+if systemctl --user is-active "systab_${id_svc}.service" &>/dev/null; then
+    pass "service job is active"
+else
+    fail "service job is active" "service not running"
+fi
+
+# Status shows Type: Service and real systemd state (mirrors tape: systab -S monitor)
+assert_output "status shows Type: Service" "Type: Service" $SYSTAB -S "$id_svc"
+assert_output "status shows active state" "Service: active" $SYSTAB -S "$id_svc"
+
+# Logs work for service jobs (mirrors tape: systab -L monitor)
+assert_output "logs for service job" "Logs for" $SYSTAB -L "$id_svc"
+
+# Service with a name (mirrors tape: -s -n monitor)
+assert_output "create service job with name" "Service created:" $SYSTAB -s -n svctest -c "sleep 3600"
+extract_id; id_svc_named=$_extracted_id
+assert_last_output_contains "service name appears in creation output" "(svctest)"
+assert_file_contains "service file has SYSTAB_NAME" \
+    "$SYSTEMD_USER_DIR/systab_${id_svc_named}.service" "^# SYSTAB_NAME=svctest$"
+
+# Disable stops the service (mirrors tape: systab -D monitor)
+assert_output "disable service job" "Disabled:" $SYSTAB -D "$id_svc"
+assert_output "disabled service shows in status" "Disabled" $SYSTAB -S "$id_svc"
+assert_output "disable already disabled service" "Already disabled:" $SYSTAB -D "$id_svc"
+
+# Enable restarts the service (mirrors tape: systab -E monitor)
+assert_output "enable service job" "Enabled:" $SYSTAB -E "$id_svc"
+assert_output "enable already enabled service" "Already enabled:" $SYSTAB -E "$id_svc"
+
+# Edit mode shows service jobs with 'service' in schedule column
+# (mirrors tape: EDITOR=nano systab -e shows "id:s | service | cmd")
+edit_output=$(EDITOR=cat $SYSTAB -e 2>&1 || true)
+if [[ "$edit_output" == *"| service |"* ]]; then
+    pass "edit mode shows service job with 'service' schedule"
+else
+    fail "edit mode shows service job with 'service' schedule" "not found in: $edit_output"
+fi
+
+# Mutually exclusive flags (mirrors tape design: -s conflicts with -t/-i/-m/-o)
+assert_failure "-s and -t are mutually exclusive" $SYSTAB -s -t daily -c "echo test"
+assert_failure "-s and -i are mutually exclusive" $SYSTAB -s -i -c "echo test"
+assert_failure "-s and -m are mutually exclusive" $SYSTAB -s -m user@example.com -c "echo test"
+assert_failure "-s and -o are mutually exclusive" $SYSTAB -s -o -c "echo test"
+
 # ============================================================
 # Clean
 # ============================================================